Linux---线程互斥和同步

1. 线程互斥

进程线程间的互斥相关背景概念

1. 临界资源：多线程执行流共享的资源就叫做临界资源
2. 临界区：每个线程内部，访问临界资源的代码，就叫做临界区
3. 互斥：任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用
4. 原子性：不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成

大部分情况，线程使用的数据都是局部变量，变量的地址空间在线程栈空间内，这种情况，变量归属单个线程，其他线程无法获得这种变量。但有时候，很多变量都需要在线程间共享，这样的变量称为共享变量，可以通过数据的共享，完成线程之间的交互。多个线程并发的操作共享变量，会带来一些问题。

操作共享变量会有问题的售票系统

#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
int ticket = 100;

void *get_ticket(void *arg)
{
  int num = (int)arg;
  while(1){
    if(ticket>0){
      usleep(1000);
      printf("thread %d,get a ticket,no: %d\n",num,ticket);
      ticket--;
    }
    else{
      break;
    }
  }
}

int main()
{
  pthread_t tid[4];
  int i = 0;
  for(;i<4;++i)
  {
    pthread_create(tid+i,NULL,get_ticket,(void*)i);
  }
  

  for(i = 0;i<4;++i)
  {
    pthread_join(tid[i],NULL);
  }

  return 0;
}

为什么可能无法获得想要结果？

1. if语句判断条件为真以后，代码可以并发的切换到其他线程（在执行if判断语句的时候，可能此时的ticket=1，然而有多个线程同时的进行着该语句的访问，然后他们都满足ticket>0的条件，然后去执行–ticket，就会出现错误）
2. usleep这个模拟漫长业务的过程，在这个漫长的业务过程中，可能有很多个线程会进入该代码段
3. –ticket操作本身就不是一个原子操作（ticket本身是存放在内存里面的，但是计算的能力只能是CPU的寄存器有，所以需要分为三步：①把内存的ticket拷贝到CPU寄存器中②CPU执行–的功能③把CPU计算完的ticket值在重新的拷贝回内存中。这其中的三个步骤，分别对应了一条汇编语句，所以这句代码不是原子性的）

对应三条汇编指令：
load：将共享变量ticket从内存加载到寄存器中
update: 更新寄存器里面的值，执行-1操作
store：将新值，从寄存器写回共享变量ticket的内存地址

要解决以上问题，需要做到三点：

1. 代码必须要有互斥行为：当代码进入临界区执行时，不允许其他线程进入该临界区。
2. 如果多个线程同时要求执行临界区的代码，并且临界区没有线程在执行，那么只能允许一个线程进入该临界区
3. 。如果线程不在临界区中执行，那么该线程不能阻止其他线程进入临界区。

要做到这三点，本质上就是需要一把锁。Linux上提供的这把锁叫互斥量。

1.1 互斥量的接口函数

初始化互斥量有两种方法：

方法1，静态分配:
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER
方法2，动态分配:
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
参数：
mutex：要初始化的互斥量
attr：NULL

销毁互斥量需要注意：

1. 使用PTHREAD_ MUTEX_INITIALIZER初始化的互斥量不需要销毁
2. 不要销毁一个已经加锁的互斥量
3. 已经销毁的互斥量，要确保后面不会有线程再尝试加锁

int pthread_mutex_destroy(pthread_mutex_t *mutex);

互斥量加锁和解锁 :

int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
返回值:成功返回0,失败返回错误号

#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
int ticket = 100;
pthread_mutex_t lock;//大家都要加同一把锁，所以应该让他们都看得见锁，所以锁需要设定为全局变量

void *get_ticket(void *arg)
{
  int num = (int)arg;
  usleep(1000);
  while(1){
    pthread_mutex_lock(&lock);
    if(ticket>0){
      usleep(1000);
      printf("thread %d,get a ticket,no: %d\n",num,ticket);
      ticket--;
      pthread_mutex_unlock(&lock);
    }
    else{
      pthread_mutex_unlock(&lock);
      break;
    }
  }
}

int main()
{
  pthread_t tid[4];
  pthread_mutex_init(&lock,NULL);
  int i = 0;
  for(;i<4;++i)
  {
    pthread_create(tid+i,NULL,get_ticket,(void*)i);
  }
  

  for(i = 0;i<4;++i)
  {
    pthread_join(tid[i],NULL);
  }

  pthread_mutex_destroy(&lock);
  return 0;
}

1.2 互斥量实现原理探究

经过上面的例子，大家已经意识到单纯的i++或者++i都不是原子的，有可能会有数据一致性问题,为了实现互斥锁操作,大多数体系结构都提供了swap或exchange指令,该指令的作用是把寄存器和内存单元的数据相交换,由于只有一条指令,保证了原子性,即使是多处理器平台,访问内存的 总线周期也有先后,一个处理器上的交换指令执行时另一个处理器的交换指令只能等待总线周期。

1.整个过程中，为1的mutex只有一份
2.exchange一条汇编完成了寄存器和内存数据的交换（这就是锁实现原子性的本质代码）

2.线程安全和可重入

2.1 概念

• 线程安全：多个线程并发同一段代码时，不会出现不同的结果。常见对全局变量或者静态变量进行操作，并且没有锁保护的情况下，会出现该问题。
• 可重入：同一个函数被不同的执行流调用，当前一个流程还没有执行完，就有其他的执行流再次进入，我们称之为重入。一个函数在重入的情况下，运行结果不会出现任何不同或者任何问题，则该函数被称为可重入函数，否则，是不可重入函数。

常见的线程不安全的情况

不保护共享变量的函数
函数状态随着被调用，状态发生变化的函数
返回指向静态变量指针的函数
调用线程不安全函数的函数

常见的线程安全的情况

每个线程对全局变量或者静态变量只有读取的权限，而没有写入的权限，一般来说这些线程是安全的
类或者接口对于线程来说都是原子操作
多个线程之间的切换不会导致该接口的执行结果存在二义性

常见不可重入的情况

调用了malloc/free函数，因为malloc函数是用全局链表来管理堆的
调用了标准I/O库函数，标准I/O库的很多实现都以不可重入的方式使用全局数据结构（C语言标准库里面有一个全局变量errno）
可重入函数体内使用了静态的数据结构

常见可重入的情况

不使用全局变量或静态变量
不使用用malloc或者new开辟出的空间
不调用不可重入函数
不返回静态或全局数据，所有数据都有函数的调用者提供
使用本地数据，或者通过制作全局数据的本地拷贝来保护全局数据

可重入与线程安全联系

函数是可重入的，那就是线程安全的
函数是不可重入的，那就不能由多个线程使用，有可能引发线程安全问题
如果一个函数中有全局变量，那么这个函数既不是线程安全也不是可重入的。

可重入与线程安全区别

可重入函数是线程安全函数的一种
线程安全不一定是可重入的，而可重入函数则一定是线程安全的。
如果将对临界资源的访问加上锁，则这个函数是线程安全的，但如果这个重入函数若锁还未释放则会产生死锁，因此是不可重入的。

3. 死锁

死锁是指在一组进程中的各个进程均占有不会释放的资源，但因互相申请被其他进程所占用不会释放的资源而处于的一种永久等待状态。（比喻：两个小女孩分别拿着5角去买棒棒糖，但是这个棒棒糖是1元的，此时这两个小女孩都想要对方的5角，并且他们都不想去放弃自己的5角，这样就会形成一个僵局，就叫死锁）

死锁四个必要条件

1. 互斥条件：一个资源每次只能被一个执行流使用
2. 请求与保持条件：一个执行流因请求资源而阻塞时，对已获得的资源保持不放
3. 不剥夺条件:一个执行流已获得的资源，在末使用完之前，不能强行剥夺
4. 循环等待条件:若干执行流之间形成一种头尾相接的循环等待资源的关系

避免死锁

• 破坏死锁的四个必要条件
• 加锁顺序一致
• 避免锁未释放的场景
• 资源一次性分配

避免死锁算法

• 死锁检测算法(了解)
• 银行家算法（了解）

4. 线程同步

同步概念：在保证数据安全的前提下，让线程能够按照某种特定的顺序访问临界资源，叫做同步

为什么要存在同步呢？
让多线程协同高效的完成某些事情。
（比喻：此时这里有一个盘子，这个盘子就是临界资源，现在来了一个A（线程）来往这个盘子中放苹果，并且A（线程）的权限还比较高，另一个B去拿苹果，那么当A放苹果前会申请锁，放完过后，释放锁，然后A又能很快的再次申请到锁，然后再去放苹果，然后发现可能一直是这个A在放苹果的过程，B就没有机会去拿苹果，所以这样的效率太低下。我们需要的是，A放完苹果以后，释放了锁，然后由于权限高又申请到了锁，然后进去发现此时的苹果依旧还在，然后A就退出去，释放锁，自己开始等待，不在去申请锁，告诉B来拿，当B进来以后拿走了苹果，释放锁，然后在申请锁进来发现没有苹果可以拿，所以此时B就释放锁，并且通知A来放苹果，自己开始等待）

4.1 条件变量函数

初始化

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：互斥量

唤醒等待
int pthread_cond_signal(pthread_cond_t *cond); 在该条件变量下等待的线程就会唤醒

#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
pthread_mutex_t lock;
pthread_cond_t cond;

void *routine_r1(void* arg)
{
  const char* name = (char*)arg;
  while(1){
    pthread_cond_wait(&cond,&lock);
    printf("get cond,%s 活动...\n",name);
  }
}

void *routine_r2(void* arg)
{
  const char* name = (char*)arg;
  while(1){
    sleep(rand()%3+1);
    pthread_cond_signal(&cond);
    printf("%s signal done ...\n",name);
  }
}

int main()
{
  pthread_mutex_init(&lock,NULL);
  pthread_cond_init(&cond,NULL);

  pthread_t t1,t2; 
  pthread_create(&t1,NULL,routine_r1,"thread1");
  pthread_create(&t2,NULL,routine_r2,"thread2");

  pthread_join(t1,NULL);
  pthread_join(t2,NULL);

  pthread_mutex_destroy(&lock);
  pthread_cond_destroy(&cond);
  return 0;
}

通过这段代码你会发现这是有顺序的在被唤醒。

#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
pthread_mutex_t lock;
pthread_cond_t cond;

void *routine_r(void* arg)
{
  const char* name = (char*)arg;
  while(1){
    pthread_cond_wait(&cond,&lock);
    printf("get cond,%s 活动...\n",name);
  }
}

void *routine_r1(void* arg)
{
  const char* name = (char*)arg;
  while(1){
    sleep(rand()%3+1);
    pthread_cond_signal(&cond);
    printf("%s signal done ...\n",name);
  }
}




int main()
{
  pthread_mutex_init(&lock,NULL);
  pthread_cond_init(&cond,NULL);

  pthread_t t1,t2,t3,t4,t5; 
  pthread_create(&t1,NULL,routine_r1,"thread1");
  pthread_create(&t2,NULL,routine_r,"thread2");
  pthread_create(&t3,NULL,routine_r,"thread3");
  pthread_create(&t4,NULL,routine_r,"thread4");
  pthread_create(&t5,NULL,routine_r,"thread5");

  pthread_join(t1,NULL);
  pthread_join(t2,NULL);
  pthread_join(t3,NULL);
  pthread_join(t4,NULL);
  pthread_join(t5,NULL);

  pthread_mutex_destroy(&lock);
  pthread_cond_destroy(&cond);
  return 0;
}

4.2 为什么pthread_cond_wait 需要互斥量?

1.在调用该函数的时候会自动的释放lock。（在执行临界区代码的时候，是先加锁的，然后判断条件不满足，于是等待，但是如果你不释放锁的话，那么别人根本就不可能进来临界区）
2.当该函数被返回时，返回到了临界区内，所以该函数会让该线程重新持有该锁。（临界区是要被保护的，所以自动的又会加上锁）