• 【Linux】锁|死锁|生产者消费者模型

    🔥博客主页： 我要成为C++领域大神
    🎥系列专栏：【C++核心编程】 【计算机网络】 【Linux编程】 【操作系统】
    ❤️感谢大家点赞👍收藏⭐评论✍️

    本博客致力于知识分享，与更多的人进行学习交流

    访问互斥

    引起互斥常见的原因：多线程访问全局资源或静态资源，多线程访问文件数据，多线程使用共享数据引发异常

    例如两个线程都在对一个全局变量num=0执行加法操作。执行加法需要有三步操作，从寄存器中取出操作数，在算术逻辑单元进行加1，将结果写回寄存器。如果让两个线程执行加法操作，当其中一个线程A的从寄存器中取出了操作数，另外一个线程B已经完成了加1，此时线程A对操作数完成加1，再放回寄存器仍是1。这就会导致两个线程访问全局资源产生互斥。

    ​

    通过下面一个代码可以观察到这一现象：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. int number;
    11. void * thread_job(void * arg)
    12. {
    13.     int tmp;
    14.     for(int i=0;i<5000;++i)
    15.     {
    16.         tmp=number;
    17.         printf("Thread 0x%x ++number:%d\n",(unsigned int)pthread_self(),++tmp);
    18.         number=tmp;
    19.     }
    20. }
    21.  
    22.  
    23. int main()
    24. {
    25.     pthread_t tid;
    26.     pthread_create(&tid,NULL,thread_job,NULL);
    27.     pthread_create(&tid,NULL,thread_job,NULL);
    28.     while(1) sleep(1);
    29.     return 0;
    30. }

    两个线程各对一个全局变量执行5000次加法，结果不可控

    ​

    锁

    互斥锁

    互斥锁可以避免多线程同时访问资源，避免资源异常，结果异常。在读写全局数据时加上锁，读写完成后解锁。

    pthread_mutex_t lock 互斥锁的数据类型

    关于锁常用的函数：

    pthread_mutex_init(&lock,NULL) 互斥锁初始化

    phtread_mutex_lock(&lock) 上锁

    pthread_mutex_unlock(&lock) 解锁

    pthread_mutex_destory(&lock)释放互斥锁

    两个线程如果同时使用一个锁，会发送锁被占用，一个线程挂起等待。

    ​

    加锁的位置很重要，可能改变线程执行流程

    ​

    通常情况是全局资源读写时需要上锁

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. pthread_mutex_t lock;//锁需要定义成全局变量，才会对多线程生效
    11. int number;
    12. void * thread_job(void * arg)
    13. {
    14.     int tmp;
    15.     for(int i=0;i<5000;++i)
    16.     {
    17.         pthread_mutex_lock(&lock);
    18.         tmp=number;
    19.         printf("Thread 0x%x ++number:%d\n",(unsigned int)pthread_self(),++tmp);
    20.         number=tmp;
    21.         pthread_mutex_unlock(&lock);
    22.     }
    23. }
    24.  
    25.  
    26. int main()
    27. {
    28.     pthread_t tid;
    29.     pthread_mutex_init(&lock,NULL);
    30.     pthread_create(&tid,NULL,thread_job,NULL);
    31.     pthread_create(&tid,NULL,thread_job,NULL);
    32.     while(1) sleep(1);
    33.     return 0;
    34. }

    ​

    惊群问题

    多线程争抢资源，因资源有限，未抢到的线程付出了无意义的系统开销

    当一个线程的互斥锁使用完毕后，其他线程都会争抢这个锁， 被唤醒并争夺资源 ，从挂起态回到运行态。当其中一个线程争抢到锁后，其余线程又回到挂起态。造成了无意义的资源浪费和系统开销。

    互斥锁等待队列是操作系统和线程库中用于管理等待互斥锁的线程的一个数据结构。它主要解决多线程环境中对共享资源的竞争问题，确保只有一个线程在某一时刻可以访问共享资源，从而避免数据竞争和不一致性。

    对优先级高的线程使用标志标记

    ​

    但是如果正在使用锁的线程释放锁后仍有时间片，它还会占用锁

    旋转锁

    提高锁的利用率，当多个进程需要同时使用锁时，其他线程不会挂起等待，一直处于运行态R。

    读写锁

    互斥锁不允许多个线程同时访问资源，资源的利用率较低，读写锁可以解决这个问题，它支持一个线程写资源，多个线程可以同时读资源，提高资源利用率。

    特点：读共享，写独占，读写互斥

    pthread_rwlock_t lock; 读写锁

    pthread_rwlock_init(&lock,NULL) 读写锁初始化

    pthread_rwlock_destroy(&lock)释放锁

    pthread_rwlock_rdlock(&lock) 读锁上锁

    pthread_rwlock_wrlock(&lock) 写锁上锁

    pthread_rwlock_unlock(&lock) 解锁

    下面是读写锁使用的demo程序

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. int number;
    11. pthread_rwlock_t lock;
    12. void *thread_read(void *arg)
    13. {
    14.     while(1)
    15.     {
    16.         pthread_rwlock_rdlock(&lock);
    17.         printf("Read Thread 0x%x Num=%d\n",(unsigned int)pthread_self(),number);
    18.         pthread_rwlock_unlock(&lock);
    19.         usleep(100000);
    20.     }
    21.  
    22. }
    23.  
    24. void *thread_write(void *arg)
    25. {
    26.     while(1)
    27.     {
    28.         pthread_rwlock_wrlock(&lock);
    29.         printf("Write Thread 0x%x Num=%d\n",(unsigned int)pthread_self(),++number);
    30.         pthread_rwlock_unlock(&lock);
    31.         usleep(100000);
    32.     }
    33. }
    34. int main()
    35. {
    36.  
    37.     pthread_t tids[8];
    38.     pthread_rwlock_init(&lock,NULL);
    39.     int i;
    40.     for(i=0;i<3;++i)
    41.     {
    42.         pthread_create(&tids[i],NULL,thread_write,NULL);
    43.     }
    44.     for(i;i<8;++i)
    45.     {
    46.         pthread_create(&tids[i],NULL,thread_read,NULL);
    47.     }
    48.     while(i--)
    49.     {
    50.         pthread_join(tids[i],NULL);
    51.     }
    52.  
    53.     pthread_rwlock_destroy(&lock);
    54.         exit(0);
    55.  
    56. }

    运行结果：写的结果各不相同，读的结果都相同

    ​

    进程互斥锁

    通过修改互斥锁属性可以将线程互斥锁变为进程互斥锁，在进程间使用。

    pthread_mutexattr_t互斥锁属性类型，默认情况下属性中均为线程互斥锁

    pthread_mutexattr_setpshared(pthread_mutexattr_t* attr,PTHREAD_PROCESS_PRIVATE | PTHREAD_PROCESS_SHARED)修改锁属性中的成员

    下面是多进程共享内存，使用了互斥锁来保护共享资源的demo程序

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. typedef struct {
    11.     int number;
    12.     pthread_mutex_t lock;
    13. } shared_t;
    14.  
    15. int main(void) {
    16.     int fd;
    17.     fd = open("PROCESS_LOCK", O_RDWR | O_CREAT, 0664);
    18.     ftruncate(fd, sizeof(shared_t)); // 扩展文件大小
    19.     
    20.     shared_t *ptr = NULL;
    21.     ptr = mmap(NULL, sizeof(shared_t), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    22.     
    23.     pid_t pid;
    24.     
    25.     // 初始化共享资源
    26.     ptr->number = 0;
    27.     
    28.     pthread_mutexattr_t attr;
    29.     // 初始化互斥锁属性
    30.     pthread_mutexattr_init(&attr);
    31.     // 设为进程间共享互斥锁
    32.     pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
    33.     // 用属性初始化互斥锁
    34.     pthread_mutex_init(&ptr->lock, &attr);
    35.     
    36.     pid = fork();
    37.     if (pid > 0) {
    38.         // 父进程
    39.         for (int i = 0; i < 5000; i++) {
    40.             pthread_mutex_lock(&ptr->lock);
    41.             printf("Parent pid %d: number = %d\n", getpid(), ++(ptr->number));
    42.             pthread_mutex_unlock(&ptr->lock);
    43.         }
    44.         wait(NULL);
    45.     } else if (pid == 0) {
    46.         // 子进程
    47.         for (int i = 0; i < 5000; i++) {
    48.             pthread_mutex_lock(&ptr->lock);
    49.             printf("Child pid %d: number = %d\n", getpid(), ++(ptr->number));
    50.             pthread_mutex_unlock(&ptr->lock);
    51.         }
    52.         exit(0);
    53.     } else {
    54.         perror("fork call failed");
    55.         exit(0);
    56.     }
    57.     
    58.     close(fd);
    59.     pthread_mutexattr_destroy(&attr);
    60.     pthread_mutex_destroy(&ptr->lock);
    61.     munmap(ptr, sizeof(shared_t));
    62.     return 0;
    63. }

    ​

    文件读写锁

    1把写锁，n把读锁，读共享，写互斥，读写互斥

    通过修改文件结构体里的文件锁结构体属性来实现上锁和解锁效果。用户需要自定义锁结构体并赋值，而后对文件默认锁结构体进行替换，实现文件上锁效果

    ​

    ​

    通过查看手册，l_type是锁的类型，有读锁，写锁，未上锁三种状态

    l_whence是设置开始加锁的位置（相对于文件整个文件的位置）

    l_start是在加锁位置的偏移量

    l_len是加锁的长度

    l_pid是当前使用锁的进程pid

    使用下面这个函数可以设置锁的状态和得到锁的状态，根据第二个参数来判断是得到锁还是上锁。

    fcntl(fd,F_GETLK, struct flock * lock) 将文件默认的锁结构体传出到lock变量中

    fcntl(fd,F_SETLK, struct flock * newlock)将自定义的newlock替换文件原有的锁结构体，实现上锁效果。F_SETLK是非阻塞上锁，F_SETLKW是阻塞上锁关键字，如果文件锁被占用，则会挂起等待。

    下面是对文件进行上锁的demo程序：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10.  
    11. int main()
    12. {
    13.     int fd=open("file_test",O_RDWR);
    14.     struct flock old;
    15.     fcntl(fd,F_GETLK,&old);
    16.     //if(old.l_type==F_UNLCK)
    17.     //{
    18.         printf("file_test lock status:F_UNLOCK\n");
    19.         struct flock newlock;
    20.         newlock.l_type=F_WRLCK;
    21.         newlock.l_whence=SEEK_SET;
    22.         newlock.l_start=0;
    23.         newlock.l_len=0;
    24.         fcntl(fd,F_SETLKW,&newlock);
    25.         printf("Process A %d set file_test lock status:F_WRLCK\n",getpid());
    26.         sleep(10);
    27.         newlock.l_type=F_UNLCK;
    28.         fcntl(fd,F_SETLKW,&newlock);
    29.         printf("Process A %d set file_test lock status:F_UNLCK\n",getpid());
    30.     //}
    31.     //else
    32.     //printf("file_test lock status:F_WRLCK\n");
    33.         return 0;
    34. }
    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10.  
    11. int main()
    12. {
    13.     int fd=open("file_test",O_RDWR);
    14.         struct flock newlock;
    15.         newlock.l_type=F_WRLCK;
    16.         newlock.l_whence=SEEK_SET;
    17.         newlock.l_start=0;
    18.         newlock.l_len=0;
    19.         fcntl(fd,F_SETLKW,&newlock);
    20.         printf("Process B %d set file_test lock status:F_WRLCK\n",getpid());
    21.         return 0;
    22. }

    运行结果：F_SETLKW是阻塞上锁关键字，文件锁被进程A占用，进程B挂起等待

    ​

    ​

    死锁问题

    锁资源有限，但多线程相互请求锁资源，导致线程永久阻塞，这种现象称为死锁。

    ​

    死锁发送的四个必要条件：

    请求与保持条件：某个线程在占用一把锁后还要请求新锁，容易引发死锁问题

    不可剥夺条件：除了占用资源的线程外，其他人无法解锁资源

    互斥条件：某个线程占用锁资源后，其他线程申请则挂起等待

    环路等待条件：每个线程都在等待相邻线程手中的资源，这种称为等待环路

    下面是产生死锁问题的demo程序

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10.  
    11. pthread_mutex_t lockA,lockB;
    12. int numA=5;
    13. int numB=6;
    14. void *thread_jobA(void* arg)
    15. {
    16.     pthread_mutex_lock(&lockA);
    17.     printf("numA = %d\n",numA);
    18.     sleep(0);
    19.     pthread_mutex_lock(&lockB);
    20.     printf("numA + numB = %d\n",numA+numB);
    21.     pthread_mutex_unlock(&lockB);
    22.     pthread_mutex_unlock(&lockA);
    23. }
    24.  
    25. void *thread_jobB(void* arg)
    26. {
    27.     pthread_mutex_lock(&lockB);
    28.     printf("numB = %d\n",numB);
    29.     sleep(0);
    30.     pthread_mutex_lock(&lockA);
    31.     printf("numA + numB = %d\n",numA+numB);
    32.     pthread_mutex_unlock(&lockA);
    33.     pthread_mutex_unlock(&lockB);
    34. }
    35.  
    36. int main()
    37. {
    38.     pthread_mutex_init(&lockA,NULL);
    39.     pthread_mutex_init(&lockB,NULL);
    40.     pthread_t tid;
    41.     pthread_create(&tid,NULL,thread_jobA,NULL);
    42.     pthread_create(&tid,NULL,thread_jobB,NULL);
    43.     while(1) sleep(1);
    44.         return 0;
    45. }

    线程A因线程B占用锁而挂起，线程B因线程A占用锁而挂起。两个线程都没有打印第二行输出。

    ​

    死锁处理

    产生死锁后，杀死死锁线程，解除死锁，而后再创建（死锁频繁，创建销毁线程开销较大）

    死锁检测

    有向图检测

    ​

    可以通过图的遍历算法检测出图中是否出现环路，如果是则已发生死锁，可以通过杀死线程的方式杀死某个节点，解除死锁。

    死锁预防

    哲学家就餐问题

    有五个哲学家，他们围坐在一张圆桌旁，桌上摆放着五个盘子和五根筷子。哲学家们的生活方式是交替进行思考和进餐。为了进餐，哲学家需要两根筷子，因此每个哲学家必须同时从自己左右两侧拿起筷子才能进餐。哲学家放下筷子时，思考开始。

    ​

    死锁：如果每个哲学家拿起自己右边的筷子，并等待左边的筷子，那么他们将永远等待下去，这就形成了死锁。

    饥饿：某个哲学家可能一直无法得到两根筷子进餐，导致饿死。

    资源竞争：哲学家们同时拿筷子的动作需要同步，以防止出现竞争条件。

    ​

    解锁死锁问题的方法

    礼貌策略：当某个哲学家拿起左手的资源，发现无法获取右手的资源，它会放下左手资源，让其他人就餐 

    活锁问题：如果哲学家同时频繁触发礼貌机制，导致所有哲学家拿起放下餐具，无法进食，饿死

    高权级策略：选中一名哲学家提高权限，此哲学家要进餐时，向相邻哲学家发送通知，让其放下资源

    高权策略弊端：由于优先级转换，可能导致多数时间，只有超级哲学家在就餐

    银行家算法

    银行家算法是一种避免死锁的算法，它通过模拟资源分配，检查在给定资源分配之后，系统是否会进入安全状态。如果会进入安全状态，则分配资源，否则不分配。

    银行家算法将资源都抽象为银行资产，每个用户借款，银行进行借款风险评估，如果风险超出阈值，禁止放款

    线程控制（条件变量）

    条件变量技术实现线程的挂起和唤醒。为线程指定执行条件，按执行条件挂起和唤醒线程。

    条件变量类型 pthread_cond_t 线程可以在条件变量上挂起，也可以从中唤醒。

    相关函数

    pthread_cond_init(pthread_cond_t *cd,NULL) 初始化条件变量

    pthread_cond_destroy(pthread_cond_t* cd,NULL) 销毁条件变量

    pthread_cond_wait(pthread_cond_t* cd, pthread_mutex_t *lock)等待条件变量的信号。与互斥锁一起使用，实现线程间的同步。在进入等待状态前，自动释放与条件变量关联的互斥锁，以便其他线程能够修改条件并发出信号。

    两次执行：
    线程第一次执行wait函数，挂起线程的同时解锁互斥锁。
    线程被唤醒的同时执行wait，上锁互斥锁

    pthread_cond_signal(pthread_cond_t * cd) 唤醒一个挂起在cd中的线程

    pthread_cond_broadcast(pthread_cond_t * cd) 唤醒所有挂起在cd中的线程

    signal函数的误唤醒，如果系统是多核处理器CPU，signal函数可能唤醒多个CPU，导致误唤醒。

    下面这段demo程序实现了条件控制线程交替工作

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. int day_night;
    11. pthread_mutex_t lock;
    12. pthread_cond_t cond;
    13.  
    14.  
    15. void * threadA_job(void *arg)
    16. {
    17.     while(1)
    18.     {
    19.         pthread_mutex_lock(&lock);
    20.         while(day_night==0)
    21.         {
    22.             pthread_cond_wait(&cond,&lock);
    23.         }
    24.             printf("Thread A TID 0x%x is working,working state:%d\n",(unsigned int)pthread_self(),day_night);
    25.             --day_night;
    26.             pthread_mutex_unlock(&lock);
    27.             pthread_cond_signal(&cond);
    28.     }
    29. }
    30.  
    31. void * threadB_job(void *arg)
    32. {
    33.     while(1)
    34.     {
    35.         pthread_mutex_lock(&lock);
    36.         while(day_night)
    37.         {
    38.             pthread_cond_wait(&cond,&lock);
    39.         }
    40.         printf("Thread B TID 0x%x is working,working state:%d\n",(unsigned int)pthread_self(),day_night);
    41.         ++day_night;
    42.         pthread_mutex_unlock(&lock);
    43.         pthread_cond_signal(&cond);
    44.     }
    45. }
    46. int main()
    47. {
    48.     pthread_t tid;
    49.     pthread_create(&tid,NULL,threadA_job,NULL);
    50.     pthread_create(&tid,NULL,threadB_job,NULL);
    51.     while(1) sleep(1);
    52.     return 0;
    53. }

    ​ 

    生产者消费者

    经典的数据传递或任务传递模型

    生产者：任务队列为满挂起，非满则添加数据

    生产者生产任务后，通知一个消费者，让它获取任务

    消费者：任务队列为空挂起，非空则获取任务执行

    消费者获取任务后，唤醒一个生产者

    需要两个条件变量

    Not_Full Not_Null

    遍历时使用环形队列实现

    ​

    下面是实现生产者消费者的demo程序：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. pthread_mutex_t lock;
    11. pthread_cond_t Not_Full;
    12. pthread_cond_t Not_Empty;
    13.  
    14. typedef struct
    15. {
    16.     int id;
    17.     char desc[1024];
    18. }data_t;
    19.  
    20. typedef struct
    21. {
    22.     data_t * container;
    23.     int Front;
    24.     int Rear;
    25.     int Max;
    26.     int Cur;
    27. }queue_t;
    28.  
    29. queue_t * Create_queue(int Max)
    30. {
    31.     queue_t * que=(queue_t *)malloc(sizeof(queue_t));
    32.     que->Front=0;
    33.     que->Rear=0;
    34.     que->Max=Max;
    35.     que->Cur=0;
    36.     que->container=(data_t*)malloc(sizeof(data_t)*Max);
    37.     return que;
    38. }
    39.  
    40. void * Customer_job(void * arg)
    41. {
    42.     pthread_detach(pthread_self());
    43.     queue_t *que=(queue_t*)arg;
    44.     data_t node;
    45.     while(1)
    46.     {
    47.     while(que->Cur==0)
    48.     {
    49.         pthread_cond_wait(&Not_Empty,&lock);
    50.     }
    51.     node=que->container[que->Rear];
    52.     printf("Customer TID 0x%x Get Data Successfully,node id:%d node desc:%s\n",(unsigned int)pthread_self(),node.id,node.desc);
    53.     --(que->Cur);
    54.     que->Rear=(que->Rear+1)%que->Max;
    55.     pthread_mutex_unlock(&lock);
    56.     pthread_cond_signal(&Not_Full);
    57.     }
    58.     pthread_exit(NULL);
    59. }
    60.  
    61. int main()
    62. {
    63.     pthread_t tid[3];
    64.     if(pthread_mutex_init(&lock,NULL)!=0 || pthread_cond_init(&Not_Empty,NULL)!=0 || pthread_cond_init(&Not_Full,NULL)!=0)
    65.     {
    66.         printf("init failed\n");
    67.         exit(0);
    68.     }
    69.     queue_t * que=Create_queue(100);
    70.     data_t node;
    71.     for(int i=0;i<3;++i)
    72.     {
    73.     pthread_create(&tid[i],NULL,Customer_job,(void*)que);
    74.     }
    75.  
    76.     //生产者循环添加任务
    77.     for(int i=0;i<20;++i)
    78.     {
    79.     node.id=i;
    80.     bzero(node.desc,sizeof(node.desc));
    81.     sprintf(node.desc,"测试数据%d",i);
    82.     pthread_mutex_lock(&lock);
    83.     que->container[que->Front]=node;
    84.     que->Front=(que->Front+1)%que->Max;
    85.     ++que->Cur;
    86.     pthread_mutex_unlock(&lock);
    87.     pthread_cond_signal(&Not_Empty);
    88.     printf("Producer TID 0x%x Add Task Successfully...\n",(unsigned int)pthread_self());
    89.     }
    90.     while(1)
    91.         sleep(1);
    92.  
    93.         return 0;
    94. }

    运行结果：实现了简单的生产者消费者模型，生产者添加任务，消费者执行任务 

    ​

  • 相关阅读:
    前端性能优化
    Spring Framework 6.0 框架
    Java数据结构技巧
    2022年9月电子学会考级试卷真题解析（含答案和所有文档下载）
    126. SAP UI5 进阶 - JSON 模型字段里的值，显示在最终 UI5 界面上的奥秘分析
    go基础语法10问
    SaaSBase：什么是捷讯通信？
    济南槐荫吴家堡 国稻种芯·中国水稻节：山东稻出黄河大米
    修复表中的名字（首字符大写，其他小写）
    iOS实时监控与报警器
  • 原文地址：https://blog.csdn.net/Coldreams/article/details/139998981