线程互斥和同步

1. 线程互斥
- 1.1 互斥量的接口函数
- 1.2 互斥量实现原理探究
2.线程安全和可重入
- 2.1 概念
3. 死锁
4. 线程同步
- 4.1 条件变量函数
- 4.2 为什么pthread_cond_wait 需要互斥量?

1. 线程互斥

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

临界资源：多线程执行流共享的资源就叫做临界资源

临界区：每个线程内部，访问临界资源的代码，就叫做临界区

互斥：任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用

原子性：不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成

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

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

#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;
}

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

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

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

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

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

要做到这三点，本质上就是需要一把锁。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

销毁互斥量需要注意：

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

#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角，这样就会形成一个僵局，就叫死锁）

死锁四个必要条件

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

避免死锁

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

避免死锁算法

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

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.当该函数被返回时，返回到了临界区内，所以该函数会让该线程重新持有该锁。（临界区是要被保护的，所以自动的又会加上锁）

Linux---线程互斥和同步相关推荐

Linux线程-互斥锁pthread_mutex_t
Linux线程-互斥锁pthread_mutex_t 在线程实际运行过程中,我们经常需要多个线程保持同步.这时可以用互斥锁来完成任务:互斥锁的使用过程中,主要有pthread_mutex_init, ...
Linux线程互斥学习笔记--详细分析
一.互斥锁为啥要有互斥? 多个进程/线程执行的先后顺序不确定,何时切出CPU也不确定. 多个进程/线程访问变量的动作往往不是原子的. 1. 操作步骤 (1)创建锁 // 创建互斥锁mutex pth ...
linux线程同步互斥说法,linux线程间的同步与互斥知识点总结
在线程并发执行的时候,我们需要保证临界资源的安全访问,防止线程争抢资源,造成数据二义性. 线程同步: 条件变量为什么使用条件变量? 对临界资源的时序可控性,条件满足会通知其他等待操作临界资源的线程, ...
Linux 线程如何实现同步与互斥
线程安全:多个执行流对临界资源的争抢访问,但是并不会造成数据的二义性线程的安全主要是通过同步和互斥来实现的同步:通过条件判断保证对临界资源访问的合理性互斥:通过同一时间的唯一访问实现对临界资源访 ...
linux 线程管理、同步机制等
线程学了那么多有关进程的东西,一个作业从一个进程开始,如果你需要执行其他的东西你可以添加一些进程,进程之间可以通信.同步.异步.似乎所有的事情都可以做了. 对的,进程是当初面向执行任务而开发出来的, ...
linux线程互斥锁
linux线程同步(1)-互斥量一.概述互斥量是线程同步的一种机制,用来保护多线程的共享资源.同一时刻,只允许一个线程对临界区进行访问. 互斥量的工作流程:创建一个互斥量,把这个互斥量的加锁调用放 ...
线程互斥和同步-- 互斥锁
一. 线程分离我们一般创建的线程是可结合的,这个时候如果我们调用pthread_jion()去等待的话,这种等待的方式是阻塞式等待,如果主线程一直等待,主线程就无法做其他的事情了,所以应该使用线程分 ...
Linux线程-互斥锁pthread_mutex_t
在线程实际运行过程中,我们经常需要多个线程保持同步.这时可以用互斥锁来完成任务:互斥锁的使用过程中,主要有pthread_mutex_init,pthread_mutex_destory,pthrea ...
QT多线程（三）线程互斥与同步
前言线程之间存在着相互制约的关系: 互斥关系,如线程争夺I/O设备而导致一方必须等待一方使用结束后方可使用同步关系,完成同一任务的线程之间,需要协调它们的工作而相互等待.交互临界区先看这个类: ...
线程互斥与同步在c#中用mutex类实现线程的互斥_Golang 并发编程与同步原语
5.1 同步原语与锁 · 浅谈 Go 语言实现原理draveness.me 当提到并发编程.多线程编程时,我们往往都离不开『锁』这一概念,Go 语言作为一个原生支持用户态进程 Goroutine 的 ...

Linux---线程互斥和同步