Linux：线程(2)

---

一、线程安全

线程安全的作用，就是保证当多个执行流(可以理解为线程)访问临界资源(多个线程都能访问到的资源)时，不会导致程序结果产生二义性。

1.线程不安全的现象

要理解线程安全，首先要理解线程不安全的原理，为什么线程会出现不安全现象？
可以由下图来进一步理解：

2.互斥锁原理

既然多个执行流访问同一个临界资源时会产生二义性问题，那么，互斥锁就很好地解决了程序二义性的问题。
互斥锁能够保证多个执行流访问了临界资源时，是原子操作的。

互斥锁的原理：
互斥锁在底层是一个互斥量，它的本质是一个计数器，计数器的取值只能是0或1，0代表不能获取互斥锁，1代表可以获取互斥锁

使用伪代码表示一下：

3.互斥锁接口

1.互斥锁初始化接口

分为动态初始化和静态初始化，函数原型和参数含义见下图：

2.互斥锁加锁接口

分为阻塞加锁，非阻塞加锁和带有超时时间的加锁，函数原型和参数含义见下图：

3.互斥锁的位置

1.初始化互斥锁的位置一定要在创建线程之前
2.加锁的位置一定要在访问(读取，修改)临界资源之前
3.要在所有可能导致线程退出的地方进行解锁，如果不进行解锁，就会导致死锁

二、死锁

如果执行流加锁完毕之后不进行解锁，就会导致其它执行流获取不到锁而进行阻塞，这种现象称为死锁

1.模拟死锁现象

下图模拟了产生死锁的过程

代码模拟：

  1 #include<stdio.h>                                                                                                                                                                        
  2 #include<unistd.h>
  3 #include<pthread.h>
  4 //互斥锁
  5 pthread_mutex_t g_lock1;
  6 pthread_mutex_t g_lock2;
  7 //模拟死锁现象：两个线程两把锁，线程1先拿到1锁又要去拿2锁，线程2先拿到2锁又想去拿1锁
  8 //线程1和线程2就会陷入死锁
  9 void* MyThreadStart1(void* arg)//线程1
 10 {
 11     (void) arg;
 12     pthread_mutex_lock(&g_lock1);//线程拿到1锁
 13     sleep(5);//拿到一锁后等待5秒钟，防止线程拿到1锁后立即去拿2锁
 14     pthread_mutex_lock(&g_lock2);
 15     return NULL;
 16 
 17 }
 18 void* MyThreadStart2(void* arg)//线程2
 19 {
 20     (void) arg;
 21     pthread_mutex_lock(&g_lock2);
 22     sleep(5);//与线程1同理
 23     pthread_mutex_lock(&g_lock1);
 24     return NULL;
 25 }
 26 int main()
 27 {   
 28     //在线程创建之前初始化互斥锁
 29     pthread_mutex_init(&g_lock1,NULL);
 30     pthread_mutex_init(&g_lock2,NULL);
 31     pthread_t tid;//线程标识符
 32     int ret = pthread_create(&tid,NULL,MyThreadStart1,NULL);//创建线程1
 33     if(ret < 0)//线程创建失败
 34     {
 35         perror("pthread_create");
 36         return 0;
 37     }
 38 	ret = pthread_create(&tid,NULL,MyThreadStart2,NULL);//创建线程2
 39     if(ret < 0)
 40     {
 41         perror("pthread_create");
 42     }
 43     while(1)
 44     {
 45         sleep(1);//主线程不要推出
 46     }
 47     //销毁互斥锁
 48     pthread_mutex_destroy(&g_lock1);
 49     pthread_mutex_destroy(&g_lock2);
 50     return 0;
 51 }              

程序执行结果如下，可以发现程序并没有结束：

使用pstack查看调用堆栈：

使用gdb attach [进程号] 或 gdb -p [进程号] 进入调试状态，可以调试已经存在的进程
再使用 thread apply all bt 命令，查看所有线程调用堆栈
t [线程编号]，切换到具体线程
bt，查看当前切换到线程的调用堆栈
f [行号] ，切换到具体哪一行
p [互斥锁] ，打印互斥锁的内容,可以查看互斥锁变量当中的成员函数
经过以上命令步骤后，可以看到的信息：

2.死锁的解决方案

要解决死锁问题，首先要了解产生死锁的条件：
1.互斥条件：一个互斥锁，在同一时刻只能被一个执行流拥有
2.循环等待(环路等待)：多个执行流各自拿着对方想要的锁，并且执行流还去请求对方的锁
3.不可剥夺：一个执行流获取互斥锁后，其他执行流不能再释放该锁，除非自己主动释放
4.请求与保持：即"吃着碗里的，看着锅里的"
因此，解决死锁的方案：
1.破坏产生死锁的必要条件(循环等待，请求与保持)
2.加锁顺序一致
3.避免锁未释放的场景
4.资源一次性分配