线程同步与互斥详解

线程同步与互斥

线程互斥

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

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

我们首先要清楚线程与线程之间的关系：

1. 如果我定义了全局变量，请问，所有的线程都可以访问吗？这里的全局变量就是临界资源，各进程采取互斥的方式，实现共享的资源称作临界资源。
2. 对全局变量做的修改比如：++和–，就有可能会有风险，++和–是否是安全的？++和–不是安全的，因为它们不是原子的

#include<string>
#include<unistd.h>
#include<ctime>
#include<pthread.h>
#include<iostream>
using namespace std;
int g_val = 100;
void* Routinue(void* args)
{
    int cnt = 5;
    while(cnt)
    {
        cout<<"thread: " << pthread_self() << "cnt: "<<cnt-- << g_val<<" " << &g_val << endl;
        sleep(1);
    }
    return (void*)10;
}
int main()
{
    pthread_t tid;
    pthread_create(&tid,nullptr,Routinue,nullptr);
    
    sleep(1);
    while(true)
    {
        cout<< "main thread g_val: " << g_val << " g_val: " << &g_val<< endl;
        sleep(1);
    }

    int ret = pthread_join(tid,nullptr);
    cout<<"main thread ret:"<<ret<<endl;//ret不是0，join失败
    return 0;
}

所有的线程数据都是共享的，所有代码和数据都是被线程共享的，被多个执行流同时访问的公共资源叫做临界资源，访问临界资源的那部分代码叫做临界区

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

比如说我们有一个售票系统，伪代码：

ticket = 100;
if(ticket > 0)
    ticket--;
else
    //wait

这里的ticket称之为临界资源，访问临界资源的那部分代码叫做临界区，即第二行和第三行

ticket–;这个操作并不是原子的

首先ticket是变量，它在内存里面，计算是在CPU当中：

1、将ticket从内存拿到CPU

2、然后CPU 进行ticket–

3、将新的ticket再返回给内存

在汇编语言角度，这是三条语句，假设ticket此时等于1，有可能一个线程在执行第一条语句(此时ticket还是1)，同时另一个线程也过来了，它检测时ticket此时也等于1，所以他也进来执行ticket–了，此时两个线程都将ticket–了，都获取到了票，但是实际上却只有一张票了，此时就有大问题了

我们来写一个简单的抢票代码：

#include<pthread.h>
#include<unistd.h>
#include<iostream>
using namespace std;
int ticket = 100;
void* get_ticket(void* arg)
{
    while(1)
    {
        if(ticket>0)
        {
            usleep(1000);
            cout<<"thread "<<pthread_self()<<"get a ticket no:"<<ticket<<endl;
            ticket--;
        }
        else
        {
            break;
        }
    }
    
}
int main()
{
    
    pthread_t = tid[];
    //创建4个线程
    for(int i = 0;i<4;i++)
    {
        pthread_create(tid+i,NULL,get_ticket,NULL);
    }
    
    //等待4个线程
    for(int i =0;i<4;i++)
    {
        pthread_join(tid[i],nullptr);
    }
    
    return 0;
}

可以看到ticket出现负数了

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

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

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

互斥量的接口

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

方法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

销毁互斥量
销毁互斥量需要注意：

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

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,失败返回错误号

调用 pthread_ lock 时，可能会遇到以下情况:

互斥量处于未锁状态，该函数会将互斥量锁定，同时返回成功
发起函数调用时，其他线程已经锁定互斥量，或者存在其他线程同时申请互斥量，但没有竞争到互斥量，那么pthread_ lock调用会陷入阻塞(执行流被挂起)，等待互斥量解锁。

售票改进：

#include<pthread.h>
#include<unistd.h>
#include<iostream>
using namespace std;
int ticket = 100;
pthread_mutex_t lock;//定义一把锁，lock是变量
void* get_ticket(void* arg)
{
    int num = (int)arg;
    while(1)
    {
        pthread_mutex_lock(&lock);//加锁
        if(ticket>0)
        {
            usleep(1000);
            cout<<"thread "<<pthread_self()<<"get a ticket no:"<<ticket<<endl;
            ticket--;
        	pthread_mutex_unlock(lock);//解锁     
        }
        else
        {
        	pthread_mutex_unlock(lock);//解锁
            break;
        }
    }
    
}
int main()
{
    
    pthread_t tid[4];
    pthread_mutex_init(&lock,NULL);
    //创建4个线程
    for(int i = 0;i<4;i++)
    {
        pthread_create(tid+i,NULL,get_ticket,NULL);
    }
    
    //等待4个线程
    for(int i =0;i<4;i++)
    {
        pthread_join(tid[i],nullptr);
    } 
    pthread_mutex_destroy(&lock);  
    return 0;
}

互斥量实现原理

1. 对临界区进行保护，所以的执行线程都必须遵守这个规则(编码保证)
2. 进入临界区访问临界资源的过程lock->访问临界区->unlock
3. 所有的线程都必须先看到同一把锁，锁本身就是临界资源！锁本身得先保证自身的安全，保证这把锁任何一个时刻只允许被一个人占用，申请锁的过程是不能有中间状态，也就是两态的，lock->原子性，unlock->原子性
4. lock->访问临界区(是需要花费时间的)->unlock，在特定线程/进程拥有锁的时候，期间有新的线程过来申请锁，这个新线程是一定申请不到的！新线程该怎么办呢？阻塞，将进程/线程对应的PCB投入到等待队列，unlock之后，进行线程、进程的唤醒操作！
5. 该如何理解POSIX pthread中的mutex?

mutex就是一个结构体：

struct mutex
{
    int lock;//0,1，如果为1说明这个锁是可申请的
    wait_queue *head;
}

6. pthread_mutex_init()/pthread_mutex_destroy()/pthread_mutex_lock()/pthread_mutex_unlock()

init是将mutex的内容初始化，destroy将内容清理，加锁是将lock由1变0，解锁是由0变1

7. 一次保证只有一个线程进入临界区，访问临界资源，就叫做互斥

在临界区中的多行代码中，线程时间片到了，当前线程被切换了，这种情况是不影响的，因为是带着锁走的

8. 加锁为什么一般效率比较低，或者影响效率

• 本来的并行执行，变成了串行执行
• 在进行线程切换的时候，是带着锁走的，也会影响效率

为了实现互斥锁操作,大多数体系结构都提供了swap或exchange指令,该指令的作用是把寄存器和内存单
元的数据相交换,由于只有一条指令,保证了原子性,即使是多处理器平台,访问内存的 总线周期也有先后,一
个处理器上的交换指令执行时另一个处理器的交换指令只能等待总线周期。 现在我们把lock和unlock的伪
代码改一下：

刚开始将al寄存器赋值为0，xchgb交换的是内存mutex的值(就是struct结构体里面的lock整形)和CPU寄存器的值，而交换就保证了只有一份1，当线程1进来交换时，此时内存中的mutex被交换成了0，即使该线程被切换了(保存上下文)，线程2来也执行交换指令(交换指令是原子的)，线程2看到内存中的mutex此时是0，0和0交换，原值都不变，接下来的判断它就不会进去了，会走else挂起等待，而线程1被切换回来时，此时它的al寄存器的值为1，所以就进入了if里面申请锁就成功了

unlock一定是原子的

可重入和线程安全

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

常见的线程不安全的情况

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

常见的线程安全情况

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

int doSomething()
{
    int myerrno = errno;
    //myerrno
}

errno是系统的全局变量，我们在使用它只读时可以定义本地变量来保存它来进行读，这样这个函数就是可重入的。

常见锁概念

死锁

死锁是指在一组进程中的各个进程均占有不会释放的资源，但因互相申请被其他进程所占用不会释放的资源而处于的一种永久等待状态。

举个例子：线程1拥有锁1，线程2拥有锁2，线程1又去申请锁2，此时锁2是被占用的，所以他被挂起了，他被挂起想醒来是需要拥有锁2的线程2去释放锁2然后去唤醒他的，但是线程2并不放手，此时线程2又去申请锁1，它也被挂起来了。他被挂起想醒来是需要拥有锁1的线程1去释放锁1然后去唤醒他的，此时线程1和线程2都处于挂起状态，就处于了永久等待状态。

死锁四个必要条件

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

死锁一定要满足这四个条件，解决死锁本质上就是破坏之中的条件

互斥条件一般是不可以破坏的，破坏了这个相当于你不用锁了，一般是不会的

请求与保持条件：可以破坏，可以内部算法实现优先级，让一个线程的锁可以在其他线程申请时给这个线程

不剥夺条件：强制把一个线程的锁清0，把这个线程的锁给另一个线程

循环等待条件：理论上也可以破坏

避免死锁

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

避免死锁算法

死锁检测算法
银行家算法

一个线程也可以产生死锁：

#include<pthread.h>
#include<unistd.h>
#include<iostream>
using namespace std;
int ticket = 100;
pthread_mutex_t lock;//定义一把锁，lock是变量
void* get_ticket(void* arg)
{
    while(1)
    {
        pthread_mutex_lock(&lock);//加锁
        if(ticket>0)
        {
            usleep(1000);
            cout<<"thread "<<pthread_self()<<"get a ticket no:"<<ticket<<endl;
            ticket--;
        	pthread_mutex_lock(&lock);//加锁   
        }
        else
        {
        	pthread_mutex_unlock(&lock);//解锁
            break;
        }
    }
    
}
int main()
{
    
    pthread_t tid[4];
    pthread_mutex_init(&lock,NULL);
    //创建4个线程
    for(int i = 0;i<1;i++)
    {
        pthread_create(tid+i,NULL,get_ticket,(void*)i);
    }
    
    //等待4个线程
    for(int i =0;i<1;i++)
    {
        pthread_join(tid[i],nullptr);
    } 
    pthread_mutex_destroy(&lock);  
    return 0;
}

此时就产生了死锁。

线程同步

什么是同步

在保证数据安全的情况下(一般使用加锁方式)，让多个执行流按照特定的顺序进行临界资源的访问，从而有效避免饥饿问题称之为同步

举个例子：你和你朋友两个人在盘子里取苹果和放苹果，你负责在盘子里放苹果，你朋友负责在盘子里取苹果，你两不能同时取和同时放，所以是互斥，你需要申请锁先加锁，然后放苹果，如果有苹果则等待，释放锁，通知你朋友来取苹果，如果没有苹果则放完苹果释放锁即可，然后你朋友来取苹果，首先申请锁，如果盘子里没有苹果则等待，释放锁，通知你来取放苹果，如果有苹果则取完苹果释放锁即可。

这样可以发现你和你朋友是按照特定顺序进行临界资源的访问。

为什么要存在同步？

多线程协同高效完成某些事情

如何编码实现？

1. 申请锁，如果条件不满足，等待，然后需要释放锁
2. 通知机制

条件变量

当一个线程互斥地访问某个变量时，它可能发现在其它线程改变状态之前，它什么也做不了。
例如一个线程访问队列时，发现队列为空，它只能等待，只到其它线程将一个节点添加到队列中。这种情况就需要用到条件变量。

这些函数是将条件被抽象封装了起来，条件变量类型：pthread_cond_t

条件变量初始化函数

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_broadcast(pthread_cond_t *cond);
int pthread_cond_signal(pthread_cond_t *cond);

我们来写一个例子：

线程2去控制线程1活动：

mycond.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>

pthread_cond_t cond;//条件变量
pthread_mutex_t lock;//锁变量

void *r1( void *arg)
{
    const char*name = (char*)arg;
    while (1){
        pthread_cond_wait(&cond, &lock);//在特定的条件下等
        printf("get cond,%s 活动...\n",name);
    }
}
void *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_t t1, t2;//两个线程对象
    
    //初始化互斥锁和条件变量
    pthread_cond_init(&cond, NULL);
    pthread_mutex_init(&lock, NULL);
	
    pthread_create(&t1, NULL, r1, "thread1");//创建线程
    pthread_create(&t2, NULL, r2, "thread2");//创建线程
    //主线程等待
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    //销毁互斥锁和条件变量
    pthread_mutex_destroy(&lock);
    pthread_cond_destroy(&cond);
    
    return 0;
}

cond：条件变量

一个线程要在cond上等，一个要把通知信息发送到cond

一个cond结构需要包含：

struct cond
{
    int value;//判断这个条件是否满足
    wait queue *head;//等待队列，等待条件的发生
}

为什么 pthread_cond_wait 需要互斥量?

• 通常的应用场景下，当前线程执行pthread_cond_wait时，处于临界区访问共享资源，存在一个mutex与该临界区相关联
• 当前线程执行pthread_cond_wait前，已经获得了和临界区相关联的mutex；执行pthread_cond_wait会阻塞，但是在进入阻塞状态前，必须释放已经获得的mutex，让其它线程能够进入临界区
• 当前线程执行pthread_cond_wait后，阻塞等待的条件满足，条件满足时会被唤醒；被唤醒后，仍然处于临界区，因此被唤醒后必须再次获得和临界区相关联的mutex

综上，调用pthread_cond_wait时，线程总是位于某个临界区，该临界区与mutex相关，pthread_cond_wait需要带有一个参数mutex，用于释放和再次获取mutex。