c/c++：线程同步（互斥锁、死锁、读写锁、条件变量、生产者和消费者模型、信号量）

目录

1. 概念

2. 互斥锁

3. 死锁

4. 读写锁

5. 条件变量

5.1 生产者和消费者模型

6. 信号量

 
1. 概念

    线程同步：

 > 当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作。
  > - 在多个线程操作一块共享数据的时候
  >   - 按照先后顺序依次访问
  >   - 有原来的 并行 -> 串行

    临界资源：一次只允许一个线程使用的资源。
    原子操作：

  > 原子操作，就是说像原子一样不可再细分不可被中途打断。

  > 一个操作是原子操作，意思就是说这个操作是以原子的方式被执行，要一口气执行完，执行过程不能够被OS的其他行为打断，是一个整体的过程，在其执行过程中，OS的其它行为是插不进来的。

 
2. 互斥锁

    互斥锁类型：

    // pthread_mutex_t 互斥锁的类型
    pthread_mutex_t mutex;

    互斥锁特点：让多个线程, 串行的处理临界区资源(一个代码块)
    互斥锁相关函数：

      #include <pthread.h>
     
      // 初始化互斥锁
      int pthread_mutex_init(pthread_mutex_t *restrict mutex,
                 const pthread_mutexattr_t *restrict attr);
          参数:
              - mutex: 互斥锁的地址
              - attr: 互相锁的属性, 使用默认属性, 赋值为NULL就可以
     
      // 释放互斥锁资源
      int pthread_mutex_destroy(pthread_mutex_t *mutex);
     
      // 将参数指定的互斥锁上锁
      // 比如: 3个线程, 第一个线程抢到了锁, 对互斥锁加锁 -> 加锁成功, 进入了临界区
      //  第二,三个个线程也对这把锁加锁, 因为已经被线程1锁定了, 线程2,3阻塞在了这把锁上 -> 不能进入临界区,
      //     当这把锁被打开, 线程2,3解除阻塞, 线程2,3开始抢锁, 谁抢到谁加锁进入临界区, 另一个继续阻塞在锁上
      int pthread_mutex_lock(pthread_mutex_t *mutex);
     
      // 尝试加锁, 如果这把锁已经被锁定了, 加锁失败, 函数直接返回, 不会阻塞在锁上
      int pthread_mutex_trylock(pthread_mutex_t *mutex);
     
      // 解锁函数
      int pthread_mutex_unlock(pthread_mutex_t *mutex);

其中：

      restrict: 修饰符, 被修饰过的变量特点: 不能被其他指针引用
          - mutex变量对应一块内存
          - 举例: pthread_mutex_t* ptr; ptr = &mutex; // error
          -  即便做了赋值, 使用ptr指针操作mutex对应的内存也是不允许的

 
3. 死锁

两个或两个以上的进程在执行过程中，因争夺共享资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁 。

死锁几种场景：

    忘记释放锁，自己将自己锁住
    单线程重复申请锁
    多线程多锁申请， 抢占锁资源（线程A有一个锁1，线程B有一个锁2。线程A试图调用lock来获取锁2就得挂起等待线程B释放，线程B也调用lock试图获得锁1。都在等对方释放，然后获得对方的锁。）

 
4. 读写锁

    读写锁类型? 是几把锁?

          1. 读写锁是一把锁
          2. 锁定读操作, 锁定写操作
          3. 类型: pthread_rwlock_t

    读写锁的特点

    /*
          1. 读操作可以并进行, 多个线程
          2. 写的时候独占资源的
          3. 写的优先级高于读的优先级
    */
    场景：

              // 1. 线程A加读锁成功, 又来了三个线程, 做读操作, 可以加锁成功----读操作是共享的, 三个新来的线程可以加读锁成功
              // 2. 线程A加写锁成功, 又来了三个线程, 做读操作, 三个线程阻塞-------加读锁失败, 会阻塞在读锁上, 写完了
              // 3. 线程A加读锁成功, 又来了B线程加写锁阻塞, 又来了C线程加读锁阻塞------写的独占的, 写的优先级高

    什么时候使用读写锁?

    互斥锁: 数据所有的读写都是串行的
    读写锁:
           - 读: 并行
           - 写: 串行
      读的频率 > 写的频率

    操作函数:

      #include <pthread.h>
      // 初始化读写锁
      int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,
                 const pthread_rwlockattr_t *restrict attr);
          参数:
              - rwlock: 读写锁地址
              - attr: 读写锁属性, 使用默认属性, 设置为: NULL
     
      // 释放读写锁资源
      int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
     
      // 加读锁
      // rwlock被加了写锁, 这时候阻塞
      // rwlock被加了读锁, 不阻塞, 可以加锁成功 -> 读共享
      int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
     
      // 尝试加读锁
      int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
     
      // 加写锁
      // rwlock -> 加了读锁, 加了写锁 多会阻塞 -> 写独占
      int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
     
      // 尝试加写锁
      int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
     
      // 读写锁解锁
      int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

    练习例子：  8个线程操作同一个全局变量，其中3个线程不定时写同一全局资源，其中5个线程不定时读同一全局资源

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <unistd.h>
    #include <errno.h>
    #include <pthread.h>
     
    int number = 1;
    pthread_rwlock_t rwlock;
     
    void* writeNum(void* arg)
    {
        while(1)
        {
            pthread_rwlock_wrlock(&rwlock);
            number++;
            usleep(100);
            printf("+++ write, tid: %ld, number: %d\n", pthread_self(), number);
            pthread_rwlock_unlock(&rwlock);
            usleep(100);
        }
        return NULL;
    }
     
    void* readNum(void* arg)
    {
        while(1)
        {
            pthread_rwlock_rdlock(&rwlock);
            printf("=== read, tid: %ld, number: %d\n", pthread_self(), number);
            pthread_rwlock_unlock(&rwlock);
            usleep(100);
        }
        return NULL;
    }
     
    int main(int argc, char *argv[])
    {
        pthread_t wtid[3], rtid[5];
        //初始化锁
        pthread_rwlock_init(&rwlock, NULL);
        //创建写进程
        for (int i=0; i<3; ++i)
        {
            pthread_create(&wtid[i],NULL, writeNum, NULL);
        }
        //创建读进程
        for (int i=0; i<5; ++i)
        {
            pthread_create(&rtid[i], NULL, readNum, NULL);
        }
     
        //回收进程
        for (int i=0; i<3; ++i)
        {
            pthread_join(wtid[i], NULL);
        }
        for (int i=0; i<5; ++i)
        {
            pthread_join(rtid[i], NULL);
        }
        //销毁锁
        pthread_rwlock_destroy(&rwlock);
        return 0;
    }

 
5. 条件变量

    条件变量不是锁
    条件变量两个动作：

    条件变量能引起某个线程的阻塞具体来说就是：

           - 某个条件满足之后, 阻塞线程
           - 某个条件满足, 线程解除阻塞

    如果使用了条件变量进行线程同步, 多个线程操作了共享数据, 不能解决数据混乱问题，解决该问题, 需要配合使用互斥锁

    条件变量类型

pthread_cond_t

    条件变量操作函数

    #include <pthread.h>
      // 初始化条件变量
      int pthread_cond_init(pthread_cond_t *restrict cond,const pthread_condattr_t *restrict attr);
          参数:
              - cond: 条件变量的地址
              - attr: 使用默认属性, 这个值设置为NULL
     
      // 释放资源
      int pthread_cond_destroy(pthread_cond_t *cond);
     
      // 线程调用该函数之后, 阻塞
      int pthread_cond_wait(pthread_cond_t *restrict cond,pthread_mutex_t *restrict mutex);
          参数:
              - cond: 条件变量
              - mutex: 互斥锁
              
      struct timespec {
          time_t tv_sec;      /* Seconds */
          long   tv_nsec;     /* Nanoseconds [0 .. 999999999] */
       };
      // 在指定的时间之后解除阻塞
      int pthread_cond_timedwait(pthread_cond_t *restrict cond,
                 pthread_mutex_t *restrict mutex, const struct timespec *restrict abstime);
          参数:
              - cond: 条件变量
              - mutex: 互斥锁
              - abstime: 阻塞的时间
                  - 当前时间 + 要阻塞的时长
                      struct timeval val;
                  可以使用函数：gettimeofday(&val, NULL);
     
      // 唤醒一个或多个阻塞在 pthread_cond_wait / pthread_cond_timedwait 函数上的线程
      int pthread_cond_signal(pthread_cond_t *cond);
     
      // 唤醒所有的阻塞在 pthread_cond_wait / pthread_cond_timedwait 函数上的线程
      int pthread_cond_broadcast(pthread_cond_t *cond);

 
5.1 生产者和消费者模型

角色分析:
      - 生产者
      - 消费者
      - 容器

    栗子：使用条件量实现 生产线和消费者模型: 生产者往链表中添加节点, 消费者删除链表节点

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <unistd.h>
    #include <errno.h>
    #include <pthread.h>
     
    pthread_cond_t cond;         //条件变量
    pthread_mutex_t mutex;       //互斥锁
     
    //连表节点
    struct Node
    {
        int number;
        struct Node* next;
    };
     
    //指向链表第一个节点的指针
    struct Node* head = NULL;
     
    // 生产者函数、
    void* producer(void* arg)
    {
        while(1)
        {
            //创建新的链表节点
            pthread_mutex_lock(&mutex);
            struct Node* pnew = (struct Node*)malloc(sizeof(struct Node));
            pnew->next = head;
            head = pnew;
            pnew->number = rand() % 1000;
            printf("add+++ node, number: %d, tid = %ld\n", pnew->number, pthread_self());
            pthread_mutex_unlock(&mutex);
     
            //生产者生产了东西，通知消费者消费
            pthread_cond_signal(&cond);
        }
        return NULL;
    }
     
    //消费者函数
    void* customer(void* arg)
    {
        while(1)
        {
            pthread_mutex_lock(&mutex);
            while (head == NULL)
            {
                //链表为空，阻塞
                pthread_cond_wait(&cond, &mutex);
            }
     
            struct Node* pnode = head;
            head = head->next;
            printf("del--- node, number: %d, tid = %ld\n", pnode->number, pthread_self());
            free(pnode);
            pthread_mutex_unlock(&mutex);
        }
     
        return NULL;
    }
     
    int main(int argc, char *argv[])
    {
        pthread_t ptid[5], ctid[5];
        pthread_cond_init(&cond,NULL);
        pthread_mutex_init(&mutex,NULL);
     
        for (int i=0; i<5; ++i)
        {
            pthread_create(&ptid[i], NULL, producer, NULL);
            pthread_create(&ctid[i], NULL, customer, NULL);
        }
     
        for (int i=0; i<5; ++i)
        {
            pthread_join(ptid[i], NULL);
            pthread_join(ctid[i], NULL);
        }
        pthread_cond_destroy(&cond);
        pthread_mutex_destroy(&mutex);
        return 0;
    }

 
6. 信号量

    信号量用在多线程多任务同步的，一个线程完成了某一个动作就通过信号量告诉别的线程，别的线程再进行某些动作。
    信号量不一定是锁定某一个资源，而是流程上的概念，比如：有A,B两个线程，B线程要等A线程完成某一任务以后再进行自己下面的步骤，这个任务 并不一定是锁定某一资源，还可以是进行一些计算或者数据处理之类。
    信号量（信号灯）与互斥锁和条件变量的主要不同在于”灯”的概念，灯亮则意味着资源可用，灯灭则意味着不可用
    信号量主要阻塞线程, 不能完全保证线程安全.
     如果要保证线程安全, 需要信号量和互斥锁一起使用.

- 信号量类型：

    sem_t
      在这个变量中记录了一个整形数, 如果这个数据 是5, 允许有五个线程访问数据
              o o o o o
              如果有一线程访问了共享资源, 这个整形数 -1, 后边又有4个线程访问了共享数据 0,
              这时候, 再有线程访问共享数据, 这些线程阻塞

- 信号量操作函数：

    #include <semaphore.h>
      // 初始化信号量
      int sem_init(sem_t *sem, int pshared, unsigned int value);
          参数:
              - sem: 信号量的地址
              - pshared: 0-> 处理线程, 1-> 处理进程
              - value: sem_t中整形数初始化
     
      // 释放资源
      int sem_destroy(sem_t *sem);
     
      // 有可能引起阻塞
      // 调用一次这个函数 sem 中整形数 --
      // 当 sem_wait 并且 sem中的整形数为0 , 阻塞了
      int sem_wait(sem_t *sem);
     
      // 当 sem_trywait 并且 sem中的整形数为0 , 返回, 不阻塞
      int sem_trywait(sem_t *sem);
     
      // 当 sem_timedwait 并且 sem中的整形数为0 , 阻塞一定的时长, 时间到达, 返回
      int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);
     
      // 当 sem_post sem 中的整形数 ++
      int sem_post(sem_t *sem);
     
      // 查看 sem中的整形数的值, 通过第二个参数返回
      int sem_getvalue(sem_t *sem, int *sval);
————————————————
版权声明：本文为CSDN博主「陈宸-研究僧」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_35883464/article/details/103547949