【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。

相关文章

SpringBoot中@Value注入静态变量方式

SpringBoot中@Value注入静态变量方式

《SpringBoot中@Value注入静态变量方式》SpringBoot中静态变量无法直接用@Value注入,需通过setter方法,@Value(${})从属性文件获取值,@Value(#{})用... 目录项目场景解决方案注解说明1、@Value("${}")使用示例2、@Value("#{}"php
阅读更多...
MySQL的JDBC编程详解

MySQL的JDBC编程详解

《MySQL的JDBC编程详解》：本文主要介绍MySQL的JDBC编程,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录前言一、前置知识1. 引入依赖2. 认识 url二、JDBC 操作流程1. JDBC 的写操作2. JDBC 的读操作总结前言本文介绍了mysq
阅读更多...
防止Linux rm命令误操作的多场景防护方案与实践

防止Linux rm命令误操作的多场景防护方案与实践

《防止Linuxrm命令误操作的多场景防护方案与实践》在Linux系统中,rm命令是删除文件和目录的高效工具,但一旦误操作,如执行rm-rf/或rm-rf/*,极易导致系统数据灾难,本文针对不同场景... 目录引言理解 rm 命令及误操作风险rm 命令基础常见误操作案例防护方案使用 rm编程 别名及安全删除
阅读更多...
Linux下MySQL数据库定时备份脚本与Crontab配置教学

Linux下MySQL数据库定时备份脚本与Crontab配置教学

《Linux下MySQL数据库定时备份脚本与Crontab配置教学》在生产环境中,数据库是核心资产之一,定期备份数据库可以有效防止意外数据丢失,本文将分享一份MySQL定时备份脚本,并讲解如何通过cr... 目录备份脚本详解脚本功能说明授权与可执行权限使用 Crontab 定时执行编辑 Crontab添加定
阅读更多...
使用docker搭建嵌入式Linux开发环境

使用docker搭建嵌入式Linux开发环境

《使用docker搭建嵌入式Linux开发环境》本文主要介绍了使用docker搭建嵌入式Linux开发环境,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面... 目录1、前言2、安装docker3、编写容器管理脚本4、创建容器1、前言在日常开发全志、rk等不同
阅读更多...
ShardingProxy读写分离之原理、配置与实践过程

ShardingProxy读写分离之原理、配置与实践过程

《ShardingProxy读写分离之原理、配置与实践过程》ShardingProxy是ApacheShardingSphere的数据库中间件,通过三层架构实现读写分离,解决高并发场景下数据库性能瓶... 目录一、ShardingProxy技术定位与读写分离核心价值1.1 技术定位1.2 读写分离核心价值二
阅读更多...
JWT + 拦截器实现无状态登录系统

JWT + 拦截器实现无状态登录系统

《JWT+拦截器实现无状态登录系统》JWT（JSONWebToken）提供了一种无状态的解决方案：用户登录后,服务器返回一个Token,后续请求携带该Token即可完成身份验证,无需服务器存储会话... 目录✅ 引言 一、JWT 是什么？ 二、技术选型 三、项目结构 四、核心代码实现4.1 添加依赖（pom
阅读更多...
GO语言短变量声明的实现示例

GO语言短变量声明的实现示例

《GO语言短变量声明的实现示例》在Go语言中,短变量声明是一种简洁的变量声明方式,使用:=运算符,可以自动推断变量类型,下面就来具体介绍一下如何使用,感兴趣的可以了解一下... 目录基本语法功能特点与var的区别适用场景注意事项基本语法variableName := value功能特点1、自动类型推
阅读更多...
基于Python实现自动化邮件发送系统的完整指南

基于Python实现自动化邮件发送系统的完整指南

《基于Python实现自动化邮件发送系统的完整指南》在现代软件开发和自动化流程中,邮件通知是一个常见且实用的功能,无论是用于发送报告、告警信息还是用户提醒,通过Python实现自动化的邮件发送功能都能... 目录一、前言：二、项目概述三、配置文件 `.env` 解析四、代码结构解析1. 导入模块2. 加载环
阅读更多...
linux系统上安装JDK8全过程

linux系统上安装JDK8全过程

《linux系统上安装JDK8全过程》文章介绍安装JDK的必要性及Linux下JDK8的安装步骤,包括卸载旧版本、下载解压、配置环境变量等,强调开发需JDK,运行可选JRE,现JDK已集成JRE... 目录为什么要安装jdk？1.查看linux系统是否有自带的jdk：2.下载jdk压缩包2.解压3.配置环境
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2