【Linux系统编程】33.读写锁、死锁、条件变量、信号量

2024-05-04 11:52
文章标签 linux 系统 条件 编程 信号量 变量 读写 死锁 33

本文主要是介绍【Linux系统编程】33.读写锁、死锁、条件变量、信号量，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

目录

读写锁

主要应用函数

读写锁状态

读写锁特性

pthread_rwlock_init

参数rwlock

参数attr

返回值

pthread_rwlock_destroy

参数rwlock

返回值

pthread_rwlock_rdlock

参数rwlock

返回值

pthread_rwlock_wrlock

参数rwlock

返回值

pthread_rwlock_unlock

参数rwlock

返回值

pthread_rwlock_tryrdlock

参数rwlock

返回值

pthread_rwlock_trywrlock

参数rwlock

返回值

测试代码1

测试结果

死锁

条件变量

主要应用函数

pthread_cond_init

参数cond

参数attr

返回值

动态初始化

静态初始化

pthread_cond_destroy

参数cond

返回值

pthread_cond_wait

参数cond

参数mutex

返回值

作用

pthread_cond_timedwait

参数cond

参数mutex

参数abstime

返回值

pthread_cond_signal

参数cond

返回值

pthread_cond_broadcast

参数cond

返回值

测试代码2

测试结果

测试代码3

测试结果

信号量

主要应用函数

sem_init

参数sem

参数pshared

参数value

返回值

sem_destroy

参数sem

返回值

sem_wait

参数sem

返回值

sem_post

参数sem

返回值

sem_trywait

参数sem

返回值

sem_timedwait

参数sem

参数abstime

测试代码4

测试结果

读写锁

       与互斥量类似，但读写锁允许更高的并行性。其特性为：写独占，读共享。读写锁也叫共享-独占锁。当读写锁以读模式锁住时，它是以共享模式锁住的；当它以写模式锁住时，它是以独占模式锁住的。

       读写锁非常适合于对数据结构读的次数远大于写的情况。

主要应用函数

pthread_rwlock_t rwlock;//定义一个读写锁变量
pthread_rwlock_init();
pthread_rwlock_destroy();
pthread_rwlock_rdlock();
pthread_rwlock_wrlock();
pthread_rwlock_tryrdlock();
pthread_rwlock_trywrlock();
pthread_rwlock_unock();

读写锁状态

读写锁只有一把，但其具备两种状态：

  1. 读模式下加锁状态（读锁）。

  2. 写模式下加锁状态（写锁）。

读写锁特性

  1. 读写锁是“写模式加锁”时， 解锁前，所有对该锁加锁的线程都会被阻塞。

  2. 读写锁是“读模式加锁”时， 如果线程以读模式对其加锁会成功；如果线程以写模式加锁会阻塞。

  3. 读写锁是“读模式加锁”时， 既有试图以写模式加锁的线程，也有试图以读模式加锁的线程。那么读写锁会阻塞随后的读模式锁请求。优先满足写模式锁。读锁、写锁并行阻塞，写锁优先级高。

pthread_rwlock_init

初始化一把读写锁。

man pthread_rwlock_init

参数rwlock

传出参数，调用时传&rwlock。

参数attr

互斥量属性，是一个传入参数，通常传NULL，选用默认属性(线程间共享)。

返回值

成功：0

失败：错误号

pthread_rwlock_destroy

销毁一把读写锁。

man pthread_rwlock_destroy

参数rwlock

传出参数，调用时传&rwlock。

返回值

成功：0

失败：错误号

pthread_rwlock_rdlock

以读方式请求读写锁。（常简称为：请求读锁）

man pthread_rwlock_rdlock

参数rwlock

传出参数，调用时传&rwlock。

返回值

成功：0

失败：错误号

pthread_rwlock_wrlock

以写方式请求读写锁。（常简称为：请求写锁）

man pthread_rwlock_wrlock

参数rwlock

传出参数，调用时传&rwlock。

返回值

成功：0

失败：错误号

pthread_rwlock_unlock

解锁。

man pthread_rwlock_unlock

参数rwlock

传出参数，调用时传&rwlock。

返回值

成功：0

失败：错误号

pthread_rwlock_tryrdlock

非阻塞以读方式请求读写锁。（非阻塞请求读锁）

man pthread_rwlock_tryrdlock

参数rwlock

传出参数，调用时传&rwlock。

返回值

成功：0

失败：错误号

pthread_rwlock_trywrlock

非阻塞以写方式请求读写锁。（非阻塞请求写锁）

man pthread_rwlock_trywrlock

参数rwlock

传出参数，调用时传&rwlock。

返回值

成功：0

失败：错误号

测试代码1

多个读线程和多个写线程同时争夺CPU。

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>
#include <string.h>pthread_rwlock_t DuXie_Suo; //读写锁
int flag;
int temp = 0;void *Du_XianCheng(void *arg) //读线程
{int num = (int)arg;while (1){flag = pthread_rwlock_rdlock(&DuXie_Suo); //读方式加读写锁if (flag != 0){printf("读方式加读写锁错误：%s\n", strerror(flag));exit(1);}printf("这是第%d个读线程，temp=%d，本线程ID是%lu。\n", num, temp, pthread_self());flag = pthread_rwlock_unlock(&DuXie_Suo); //解读写锁if (flag != 0){printf("解读写锁错误：%s\n", strerror(flag));exit(1);}sleep(2);}return NULL;
}void *Xie_XianCheng(void *arg) //写线程
{int num = (int)arg;int old_temp; //旧的temp值while (1){flag = pthread_rwlock_wrlock(&DuXie_Suo); //写方式加读写锁if (flag != 0){printf("写方式加读写锁错误：%s\n", strerror(flag));exit(1);}old_temp = temp;usleep(1);temp++;printf("这是第%d个写线程，old_temp=%d，temp=%d，本线程ID是%lu。\n", num, old_temp, temp, pthread_self());flag = pthread_rwlock_unlock(&DuXie_Suo); //解读写锁if (flag != 0){printf("解读写锁错误：%s\n", strerror(flag));exit(1);}sleep(3);}return NULL;
}int main(int argc, char *argv[])
{pthread_t ZiXianCheng_ID[8]; //子线程IDflag = pthread_rwlock_init(&DuXie_Suo, NULL); //初始化读写锁if (flag != 0){printf("初始化读写锁错误：%s\n", strerror(flag));exit(1);}//创建8个子线程for (int i = 0; i < 8; i++){if (i < 3){flag = pthread_create(&ZiXianCheng_ID[i], NULL, Xie_XianCheng, (void *)(i + 1)); //创建写子线程}else{flag = pthread_create(&ZiXianCheng_ID[i], NULL, Du_XianCheng, (void *)(i + 1)); //创建读子线程}if (flag != 0){printf("创建第%d个子线程错误：%s\n", i + 1, strerror(flag));exit(1);}}printf("开始回收子线程！\n");for (int i = 0; i < 8; i++){flag = pthread_join(ZiXianCheng_ID[i], NULL);if (flag != 0){printf("回收第%d个子线程错误：%s\n", i + 1, strerror(flag));exit(1);}}printf("回收子线程完成！\n");flag = pthread_rwlock_destroy(&DuXie_Suo); //销毁读写锁if (flag != 0){printf("销毁读写锁错误：%s\n", strerror(flag));exit(1);}pthread_exit(NULL);return 0;
}

测试结果

死锁

是使用不恰当导致的现象。

  1. 线程试图对同一个互斥量A加锁两次。

  2. 线程1拥有A锁，请求获得B锁；线程2拥有B锁，请求获得A锁。

条件变量

       条件变量本身不是锁！但它也可以造成线程阻塞。通常与互斥锁配合使用。给多线程提供一个会合的场所。

主要应用函数

pthread_cond_t cond;//定义条件变量
pthread_cond_init();
pthread_cond_destroy();
pthread_cond_wait();
pthread_cond_timedwait();
pthread_cond_signal();
pthread_cond_broadcast();

pthread_cond_init

初始化一个条件变量。

man pthread_cond_init

参数cond

条件变量。

参数attr

条件变量属性，通常为默认值，传NULL即可。

返回值

成功：0

失败：错误号

动态初始化

pthread_cond_t cond;
pthread_cond_init(&cond,NULL);	//动态初始化

静态初始化

pthread_cond_t cond=PTHREAD_COND_INITIALIZER;	//静态初始化

pthread_cond_destroy

销毁一个条件变量。

man pthread_cond_destroy

参数cond

条件变量。

返回值

成功：0

失败：错误号

pthread_cond_wait

阻塞等待一个条件变量。

man pthread_cond_wait

参数cond

条件变量。

参数mutex

传出参数，调用时传&mutex，互斥锁。

返回值

成功：0

失败：错误号

作用

  1. 阻塞等待条件变量cond（参1）满足。

  2. 释放已掌握的互斥锁（解锁互斥量）相当于pthread_mutex_unlock(&mutex);

  3. 当被唤醒，pthread_cond_wait函数返回时，解除阻塞并重新申请获取互斥锁pthread_mutex_lock(&mutex);

1、2为一个原子操作。

pthread_cond_timedwait

限时等待一个条件变量。

man pthread_cond_timedwait

参数cond

条件变量。

参数mutex

传出参数，调用时传&mutex，互斥锁。

参数abstime

绝对时间。

struct timespec {time_t tv_sec; /* seconds  秒*/long tv_nsec; /* nanosecondes 纳秒*/
}

 用法：

time_t cur = time(NULL); //获取当前时间。
struct timespec t; //定义 timespec 结构体变量 t
t.tv_sec = cur+1; //定时 1 秒
pthread_cond_timedwait (&cond, &mutex, &t); //传参

返回值

成功：0

失败：错误号

pthread_cond_signal

唤醒至少一个阻塞在条件变量上的线程。

man pthread_cond_signal

参数cond

条件变量。

返回值

成功：0

失败：错误号

pthread_cond_broadcast

唤醒全部阻塞在条件变量上的线程。

man pthread_cond_broadcast

参数cond

条件变量。

返回值

成功：0

失败：错误号

测试代码2

       有两个线程，一个模拟生产者行为，一个模拟消费者行为。两个线程同时操作一个共享资源，生产者向其中添加产品，消费者从中消费掉产品。线程同步典型的案例即为生产者消费者模型，而借助条件变量来实现这一模型，是比较常见的一种方法。

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>
#include <string.h>pthread_mutex_t HuChiSuo = PTHREAD_MUTEX_INITIALIZER;         //互斥锁，静态初始化
pthread_cond_t TiaoJian_BianLiang = PTHREAD_COND_INITIALIZER; //条件变量，静态初始化
struct NengLiang                                              //能量类型的结构体
{struct NengLiang *next;int num;
};
struct NengLiang *Bing; //饼
int flag;void *ShengChanZhe(void *arg) //生产者
{while (1){struct NengLiang *ZuoBing = malloc(sizeof(struct NengLiang)); //做饼ZuoBing->num = rand() % 1000 + 1;flag = pthread_mutex_lock(&HuChiSuo); //加锁if (flag != 0){printf("加锁错误：%s\n", strerror(flag));exit(1);}ZuoBing->next = Bing;Bing = ZuoBing;printf("这是生产者，做的饼是%d。\n", ZuoBing->num);flag = pthread_mutex_unlock(&HuChiSuo); //解读写锁if (flag != 0){printf("解锁错误：%s\n", strerror(flag));exit(1);}pthread_cond_signal(&TiaoJian_BianLiang); //唤醒阻塞线程，叫消费者吃饼sleep(rand() % 3);}return NULL;
}void *XiaoFeiZhi(void *arg) //消费者
{while (1){struct NengLiang *ChiBing;            //吃饼flag = pthread_mutex_lock(&HuChiSuo); //加锁if (flag != 0){printf("加锁错误：%s\n", strerror(flag));exit(1);}if (Bing == NULL) //如果饼为空，说明没有饼{flag = pthread_cond_wait(&TiaoJian_BianLiang, &HuChiSuo); //阻塞等待饼的产生if (flag != 0){printf("阻塞等待错误：%s\n", strerror(flag));exit(1);}}ChiBing = Bing;Bing = ChiBing->next;printf("这是消费者，吃的饼是%d。\n", ChiBing->num);flag = pthread_mutex_unlock(&HuChiSuo); //解锁if (flag != 0){printf("解读写锁错误：%s\n", strerror(flag));exit(1);}free(ChiBing); //清空结构体内容sleep(rand() % 3);}return NULL;
}int main(int argc, char *argv[])
{pthread_t ShengChanZhe_ID; //生产者线程IDpthread_t XiaoFeiZhe_ID;   //消费者线程ID//创建线程flag = pthread_create(&ShengChanZhe_ID, NULL, ShengChanZhe, NULL); //创建生产者子线程if (flag != 0){printf("创建生产者子线程错误：%s\n", strerror(flag));exit(1);}flag = pthread_create(&XiaoFeiZhe_ID, NULL, XiaoFeiZhi, NULL); //创建消费者子线程if (flag != 0){printf("创建消费者子线程错误：%s\n", strerror(flag));exit(1);}printf("开始回收子线程！\n");flag = pthread_join(ShengChanZhe_ID, NULL);if (flag != 0){printf("回收生产者子线程错误：%s\n", strerror(flag));exit(1);}flag = pthread_join(XiaoFeiZhe_ID, NULL);if (flag != 0){printf("回收消费者子线程错误：%s\n", strerror(flag));exit(1);}printf("回收子线程完成！\n");flag = pthread_mutex_unlock(&HuChiSuo); //销毁读写锁if (flag != 0){printf("销毁互斥锁错误：%s\n", strerror(flag));exit(1);}pthread_exit(NULL);return 0;
}

测试结果

测试代码3

多个消费者的情况下，争饼吃。

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>
#include <string.h>pthread_mutex_t HuChiSuo = PTHREAD_MUTEX_INITIALIZER;         //互斥锁，静态初始化
pthread_cond_t TiaoJian_BianLiang = PTHREAD_COND_INITIALIZER; //条件变量，静态初始化
struct NengLiang                                              //能量类型的结构体
{struct NengLiang *next;int num;
};
struct NengLiang *Bing; //饼
int flag;void *ShengChanZhe(void *arg) //生产者
{while (1){struct NengLiang *ZuoBing = malloc(sizeof(struct NengLiang)); //做饼ZuoBing->num = rand() % 1000 + 1;flag = pthread_mutex_lock(&HuChiSuo); //加锁if (flag != 0){printf("加锁错误：%s\n", strerror(flag));exit(1);}ZuoBing->next = Bing;Bing = ZuoBing;printf("这是生产者，做的饼是%d。\n", ZuoBing->num);flag = pthread_mutex_unlock(&HuChiSuo); //解读写锁if (flag != 0){printf("解锁错误：%s\n", strerror(flag));exit(1);}pthread_cond_signal(&TiaoJian_BianLiang); //唤醒阻塞线程，叫消费者吃饼sleep(rand() % 2);}return NULL;
}void *XiaoFeiZhi(void *arg) //消费者
{while (1){struct NengLiang *ChiBing;            //吃饼flag = pthread_mutex_lock(&HuChiSuo); //加锁if (flag != 0){printf("加锁错误：%s\n", strerror(flag));exit(1);}while (Bing == NULL) //如果饼为空，说明没有饼，多个消费者，需要多次判断{flag = pthread_cond_wait(&TiaoJian_BianLiang, &HuChiSuo); //阻塞等待饼的产生if (flag != 0){printf("阻塞等待错误：%s\n", strerror(flag));exit(1);}}ChiBing = Bing;Bing = ChiBing->next;printf("这是消费者，吃的饼是%d，线程ID是%lu。\n", ChiBing->num, pthread_self());flag = pthread_mutex_unlock(&HuChiSuo); //解锁if (flag != 0){printf("解读写锁错误：%s\n", strerror(flag));exit(1);}free(ChiBing); //清空结构体内容sleep(rand() % 5);}return NULL;
}int main(int argc, char *argv[])
{pthread_t ShengChanZhe_ID; //生产者线程IDpthread_t XiaoFeiZhe_ID;   //消费者线程ID//创建线程flag = pthread_create(&ShengChanZhe_ID, NULL, ShengChanZhe, NULL); //创建生产者子线程if (flag != 0){printf("创建生产者子线程错误：%s\n", strerror(flag));exit(1);}for (int i = 0; i < 3; i++){flag = pthread_create(&XiaoFeiZhe_ID, NULL, XiaoFeiZhi, NULL); //创建消费者子线程if (flag != 0){printf("创建消费者子线程错误：%s\n", strerror(flag));exit(1);}}printf("开始回收子线程！\n");flag = pthread_join(ShengChanZhe_ID, NULL);if (flag != 0){printf("回收生产者子线程错误：%s\n", strerror(flag));exit(1);}flag = pthread_join(XiaoFeiZhe_ID, NULL);if (flag != 0){printf("回收消费者子线程错误：%s\n", strerror(flag));exit(1);}printf("回收子线程完成！\n");flag = pthread_mutex_unlock(&HuChiSuo); //销毁读写锁if (flag != 0){printf("销毁互斥锁错误：%s\n", strerror(flag));exit(1);}pthread_exit(NULL);return 0;
}

测试结果

信号量

应用于线程、进程间同步。

相当于初始化值为N的互斥量。N值：表示可以同时访问共享数据区的线程数。

主要应用函数

sem_t sem; //规定信号量 sem 不能 < 0。本质仍是结构体。但应用期间可简单看作为整数，忽略实现细节。
sem_init();
sem_destroy();
sem_wait();
sem_trywait();
sem_timedwait();
sem_post();

sem_init

初始化一个信号量。

man sem_init

参数sem

信号量。

参数pshared

0：用于线程间同步

1：用于进程间同步

参数value

同时访问的线程数。

返回值

成功：0

失败：错误号

sem_destroy

销毁一个信号量。

man sem_destroy

参数sem

信号量。

返回值

成功：0

失败：错误号

sem_wait

给信号量加锁。一次调用，做一次--操作，当信号量的值为0时，再次--就会阻塞。

man sem_wait

参数sem

信号量。一次调用，做一次++操作，当信号量的值为N时，再次++就会阻塞。

返回值

成功：0

失败：错误号

sem_post

N值，给信号量解锁。

man sem_post

参数sem

信号量。

返回值

成功：0

失败：错误号

sem_trywait

尝试对信号量加锁。

man sem_trywait

参数sem

信号量。

返回值

成功：0

失败：错误号

sem_timedwait

限时尝试对信号量加锁。

man sem_timedwait

参数sem

信号量。

参数abstime

绝对时间。

struct timespec {time_t tv_sec; /* seconds  秒*/long tv_nsec; /* nanosecondes 纳秒*/
}

用法：

time_t cur = time(NULL); //获取当前时间。
struct timespec t; //定义 timespec 结构体变量 t
t.tv_sec = cur+1; //定时 1 秒
sem_timedwait(&sem,&t); //传参

测试代码4

       使用信号量完成线程间同步，模拟生产者，消费者问题。 如果□中有数据，生产者不能生产，只能阻塞。如果□中没有数据，消费者不能消费，只能等待数据。

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <semaphore.h>
#include <pthread.h>
#include <string.h>#define NUM 5int HuoJia[NUM];              //货架
sem_t KongHuoJia_XinHaoLiang; //空货架信号量
sem_t ChanPin_XinHaoLiang;    //产品信号量
int flag;void *ShengChanZhe(void *arg) //生产者
{int i = 0;while (1){flag = sem_wait(&KongHuoJia_XinHaoLiang); //阻塞等待生产货物if (flag != 0){printf("阻塞等待生产货物错误：%s\n", strerror(flag));exit(1);}HuoJia[i] = rand() % 1000 + 1;printf("这是生产者，生产的货物是%d。\n", HuoJia[i]);i++;i = i % NUM;flag = sem_post(&ChanPin_XinHaoLiang); //增加货物，产品if (flag != 0){printf("增加货物错误：%s\n", strerror(flag));exit(1);}sleep(rand() % 2);}return NULL;
}void *XiaoFeiZhi(void *arg) //消费者
{int i = 0;while (1){flag = sem_wait(&ChanPin_XinHaoLiang); //阻塞等待消费货物，产品if (flag != 0){printf("阻塞等待消费货物：%s\n", strerror(flag));exit(1);}printf("这是消费者，消费的产品是%d。\n", HuoJia[i]);HuoJia[i] = 0;i++;i = i % NUM;flag = sem_post(&KongHuoJia_XinHaoLiang); //增加空货架if (flag != 0){printf("增加空货架错误：%s\n", strerror(flag));exit(1);}sleep(rand() % 3);}return NULL;
}int main(int argc, char *argv[])
{pthread_t ShengChanZhe_ID; //生产者线程IDpthread_t XiaoFeiZhe_ID;   //消费者线程ID//初始化信号量flag = sem_init(&KongHuoJia_XinHaoLiang, 0, NUM);if (flag != 0){printf("初始化空货架信号量错误：%s\n", strerror(flag));exit(1);}flag = sem_init(&ChanPin_XinHaoLiang, 0, 0);if (flag != 0){printf("初始化产品信号量错误：%s\n", strerror(flag));exit(1);}//创建线程flag = pthread_create(&ShengChanZhe_ID, NULL, ShengChanZhe, NULL); //创建生产者子线程if (flag != 0){printf("创建生产者子线程错误：%s\n", strerror(flag));exit(1);}flag = pthread_create(&XiaoFeiZhe_ID, NULL, XiaoFeiZhi, NULL); //创建消费者子线程if (flag != 0){printf("创建消费者子线程错误：%s\n", strerror(flag));exit(1);}printf("开始回收子线程！\n");flag = pthread_join(ShengChanZhe_ID, NULL);if (flag != 0){printf("回收生产者子线程错误：%s\n", strerror(flag));exit(1);}flag = pthread_join(XiaoFeiZhe_ID, NULL);if (flag != 0){printf("回收消费者子线程错误：%s\n", strerror(flag));exit(1);}printf("回收子线程完成！\n");//销毁信号量flag = sem_destroy(&KongHuoJia_XinHaoLiang); //销毁空货架信号量if (flag != 0){printf("销毁空货架信号量错误：%s\n", strerror(flag));exit(1);}flag = sem_destroy(&ChanPin_XinHaoLiang); //销毁产品信号量if (flag != 0){printf("销毁产品信号量错误：%s\n", strerror(flag));exit(1);}pthread_exit(NULL);return 0;
}

测试结果

这篇关于【Linux系统编程】33.读写锁、死锁、条件变量、信号量的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/959137。

相关文章

Linux系统性能检测命令详解

Linux系统性能检测命令详解

《Linux系统性能检测命令详解》本文介绍了Linux系统常用的监控命令（如top、vmstat、iostat、htop等）及其参数功能,涵盖进程状态、内存使用、磁盘I/O、系统负载等多维度资源监控,... 目录toppsuptimevmstatIOStatiotopslabtophtopdstatnmon
阅读更多...
c++ 类成员变量默认初始值的实现

c++ 类成员变量默认初始值的实现

《c++类成员变量默认初始值的实现》本文主要介绍了c++类成员变量默认初始值,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧... 目录C++类成员变量初始化c++类的变量的初始化在C++中，如果使用类成员变量时未给定其初始值，那么它将被
阅读更多...
C#读写文本文件的多种方式详解

C#读写文本文件的多种方式详解

《C#读写文本文件的多种方式详解》这篇文章主要为大家详细介绍了C#中各种常用的文件读写方式,包括文本文件,二进制文件、CSV文件、JSON文件等,有需要的小伙伴可以参考一下... 目录一、文本文件读写1. 使用 File 类的静态方法2. 使用 StreamReader 和 StreamWriter二、二进
阅读更多...
在Linux中改变echo输出颜色的实现方法

在Linux中改变echo输出颜色的实现方法

《在Linux中改变echo输出颜色的实现方法》在Linux系统的命令行环境下,为了使输出信息更加清晰、突出,便于用户快速识别和区分不同类型的信息,常常需要改变echo命令的输出颜色,所以本文给大家介... 目python录在linux中改变echo输出颜色的方法技术背景实现步骤使用ANSI转义码使用tpu
阅读更多...
linux hostname设置全过程

linux hostname设置全过程

《linuxhostname设置全过程》：本文主要介绍linuxhostname设置全过程,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录查询hostname设置步骤其它相关点hostid/etc/hostsEDChina编程A工具license破解注意事项总结以RHE
阅读更多...
Linux中压缩、网络传输与系统监控工具的使用完整指南

Linux中压缩、网络传输与系统监控工具的使用完整指南

《Linux中压缩、网络传输与系统监控工具的使用完整指南》在Linux系统管理中,压缩与传输工具是数据备份和远程协作的桥梁,而系统监控工具则是保障服务器稳定运行的眼睛,下面小编就来和大家详细介绍一下它... 目录引言一、压缩与解压：数据存储与传输的优化核心1. zip/unzip：通用压缩格式的便捷操作2.
阅读更多...
Linux中SSH服务配置的全面指南

Linux中SSH服务配置的全面指南

《Linux中SSH服务配置的全面指南》作为网络安全工程师,SSH（SecureShell）服务的安全配置是我们日常工作中不可忽视的重要环节,本文将从基础配置到高级安全加固,全面解析SSH服务的各项参... 目录概述基础配置详解端口与监听设置主机密钥配置认证机制强化禁用密码认证禁止root直接登录实现双因素
阅读更多...
Go语言数据库编程GORM 的基本使用详解

Go语言数据库编程GORM 的基本使用详解

《Go语言数据库编程GORM的基本使用详解》GORM是Go语言流行的ORM框架,封装database/sql,支持自动迁移、关联、事务等,提供CRUD、条件查询、钩子函数、日志等功能,简化数据库操作... 目录一、安装与初始化1. 安装 GORM 及数据库驱动2. 建立数据库连接二、定义模型结构体三、自动迁
阅读更多...
在Linux终端中统计非二进制文件行数的实现方法

在Linux终端中统计非二进制文件行数的实现方法

《在Linux终端中统计非二进制文件行数的实现方法》在Linux系统中,有时需要统计非二进制文件（如CSV、TXT文件）的行数,而不希望手动打开文件进行查看,例如,在处理大型日志文件、数据文件时,了解... 目录在linux终端中统计非二进制文件的行数技术背景实现步骤1. 使用wc命令2. 使用grep命令
阅读更多...
Linux如何快速检查服务器的硬件配置和性能指标

Linux如何快速检查服务器的硬件配置和性能指标

《Linux如何快速检查服务器的硬件配置和性能指标》在运维和开发工作中,我们经常需要快速检查Linux服务器的硬件配置和性能指标,本文将以CentOS为例,介绍如何通过命令行快速获取这些关键信息,... 目录引言一、查询CPU核心数编程（几C？）1. 使用 nproc（最简单）2. 使用 lscpu（详细信
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2