线程安全与重入

1. 概念

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

2.常见的线程不安全情况

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

3.常见的线程安全情况

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

4.常见的不可重入情况

• 调用了malloc/free函数，因为malloc函数是用全局链表来管理堆的
• 调用了标准I/O库函数，标准I/O库的很多实现都以不可重入的方式使用全局数据结构
• 可重入函数体内使用了静态的数据结构

5.常见可重入的情况

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

6.可重入与线程安全的联系

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

7.可重入与线程安全的区别

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

互斥锁

1.定义互斥锁

pthread_mutex_t:互斥锁变量类型
eg：pthread_mutex_t lock;

2.初始化互斥锁

动态需要配合pthread_mutex_destory(pthread_mutex_t*)进行销毁
int pthread_mutex_init(pthread_mutex,const pthread_mutexattr_t *attr)

• mutex:互斥锁变量，传参的时候传入互斥锁变量的地址
• attr：互斥锁的属性，一般情况下，我们不关心，采用默认属性，传NULL
  静态的不需要进行销毁

pthread_mutex_t mutex=PTHREAD_MUTEX_INITTALIZER

• pthread_mutexattr_t 本身是一个结构体类型，PTHREAD_MUTEX_INITALIZER是一个结构体的值，使用这种方式可以直接填充pthread_mutexattr_t这个结构体

3.加锁

int pthread_mutex _lock(pthread_t* mutex)---->阻塞加锁操作

• mutex：传入互斥锁变量的地址，来进行加锁操作
• 如果使用该接口进行加锁操作的时候如果计数器当中的值为1，意味着可以加锁，加锁操作之后，对计数器当中的值从1变成0
• 如果计数器当中的值为0，意味着不可以加锁，该接口阻塞等待，执行流不会往下执行

int pthread_mutex _trylock(pthread_t* mutex)----->非阻塞加锁操作
mutex：传入互斥锁变量的地址，来进行加锁操作
如果使用该接口进行加锁操作的时候：

• 如果计数器当中的值为1，意味着可以加锁，加锁操作之后，对计数器当中的值从1变成0
• 如果计数器当中的的值为0，意味着不可以加锁，该接口直接返回，不进行阻塞等待，返回EBUSY（拿不到互斥锁）
• 一般在使用trylock这样的接口进行加锁操作的时候，一般采用循环加锁的方式，防止拿不到锁的资源而直接返回。从而可以直接访问临界资源，导致程序产生二义性的结果

int pthread_mutex_timelock(pthread_mutex_t* mutex,const struct timespec* abs_timeout) ----->带有超时时间的加锁接口

• mutex：互斥锁变量
• abs_timeout:加锁超时时间，当加锁的时候，超过加锁的超时时间之后，还没有获得互斥锁，则报错返回，不进行阻塞等待，返回ETIMEOUT
• struct timespce有两个变量，第一个变量代表秒，第二个代表纳秒

4.解锁

int pthread_mutex_unlock(pthread_mutex_t* mutex)
不管是pthread_mutex_lock或者pthread_mutex_trylock还是pthread_mutex_timelock进行加锁操作，使用pthread_mutex_unlock都可以解锁操作

5.销毁互斥锁

int pthread_mutex_destory(pthread_t* mutex)
互斥锁销毁接口，如果使用互斥锁完成之后不进行销毁，会造成内存泄漏

6.互斥锁加锁解锁的底层实现原理

互斥量计数器本身也是一个变量，这个变量的取值为0或者1，对于这样的变量进行加加或者减减的时候，难道就是原子性吗？

不论哪一种情况，都会先将寄存器当中的值变为0
加锁的时候：将寄存器当中的值和内存当中的值直接进行互换，互换的指令是xchgb，而这种操作是原子性的，一步完成

• 当计数器的值为1的时候，表示可以加锁操作，当寄存器和内存的值进行一步交换之后，相当于给计数器的值减1操作了
• 当计数器的值为0的时候，表示不可以加锁，当寄存器的值和内存的值进行一步交换之后，并没有对计数器当前的值做到真实的修改，当前的执行流就被挂起等待

1.互斥锁在哪里定义，在哪里进行初始化，在哪里进行销毁
定义：对于C语言程序，通常需要在不同的函数当中使用，所以通常定义位全局变量
对于C++语言程序，因为有类或者结构体，通常定义为类的成员变量
初始化：必须在创建线程之初就先初始化互斥锁变量
销毁：必须在线程退出之后，再进行销毁互斥锁变量
注意;一定不要销毁正在被执行流使用的互斥锁变量，否则可能导致死锁
2.在哪里进行加锁
在访问临界资源之前就需要进行加锁操作
3.在哪里进行解锁
在所有又可能退出的地方都需要进行解锁操作，如果一个执行流进行加锁之后，该执行流直接推出掉，会导致其他想要获取该互斥锁的执行流卡死
4.如果一个执行流加锁了，但是该执行流没有解锁操作，造成所有想加该互斥锁的执行流陷入阻塞等待（死锁）

死锁

什么是死锁

• 程序当中有一个执行流没有释放锁资源，会导致其他想要获取该互斥锁的执行流陷入阻塞等待，这种情况称之为死锁.
• 程序当中，每一个执行流都占有一把互斥锁，但是由于各个执行流在占有互斥锁的情况下，还想申请对方的锁，这种情况也会导致死锁（吃着碗里的看着锅里的）

死锁的四个必要条件

• 互斥条件：每一把锁只能被一个执行流所占用
• 请求与保持条件：A执行流已经占用了一个互斥锁还想去申请被占用的B执行流的互斥锁，而B执行流正好想申请A的互斥锁
• 循环等待条件：若干个执行流在请求锁资源的情况下，形成了一个闭环
• 不可剥夺：只有当前拿着互斥锁的线程才可以释放该互斥锁

避免死锁的方法

• 1.破坏必要条件
• 2.加锁顺序一致
• 3.避免锁不被释放
• 4.一次性分配资源：对于执行流在完成某件事情的时候，需要的资源一次性分配够，防止需要的资源被其他加锁的线程所占用，导致该执行流阻塞

小试牛刀
创建多个线程，同时访问全局的临界资源并进行减减操作，对临界资源进行加锁保护，使得程序避免产生二义性

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#define count 3
int tickets=100;
pthread_mutex_t lock;//定义互斥锁
void* thread_start(void *arg)
{
//    void(arg);
//访问临界资源count必须要加互斥锁，否则会使不同的线程访问同一临界资源，产生程序的二义性while(1){pthread_mutex_lock(&lock);if(tickets>0){printf("我是%p 号线程，我抢到第%d张票\n",pthread_self(),tickets);tickets--;}else{//必须在所有程序可能退出的出口解锁，否则会死锁pthread_mutex_unlock(&lock);break;}pthread_mutex_unlock(&lock);}return NULL;
}
int main()
{//创建多个线程pthread_t tid[count];pthread_mutex_init(&lock,NULL);int i=0;for(;i<count;i++){int ret=pthread_create(&tid[i],NULL,thread_start,NULL);if(ret<0){perror("pthread_create");return 0;}}//线程等待for(i=0;i<count;i++){pthread_join(tid[i],NULL);}pthread_mutex_destroy(&lock);//销毁互斥锁，，静态的不需要销毁
sleep(5);return 0;
}