Linux_线程互斥(原子性的解释_Linux互斥锁mutex(初始化与销毁)_mutex锁原子性的实现分析_可重入与线程安全_死锁_阻塞)
文章目录
1.线程互斥背景知识(临界资源，互斥，原子性定义)
- 临界资源：多执行流下共享的资源称为临界资源，每个线程内部访问临界资源的代码称为临界区
- 互斥：为了保护临界资源，在任何时刻只有一个执行流进入临界区访问临界资源。
- 原子性：不会被任何调度打断的操作。通常有两态1.完成 2.未完成
2.对临界资源保护的重要性
如果临界资源不保护
#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
int cout=1000;
void*Del(void*meg)
{
int Num=(int)meg;
while(1)
{
if(cout>0)
{
usleep(10000);
cout--;
printf("pthread%d cout=%dn",Num,cout);
}
else
{
break;
}
}
}
int main()
{
pthread_t tid[4];
for(int i=0;i<4;i++)
{
pthread_create(&tid[i],NULL,Del,(void*)i);
}
for(int i=0;i<4;i++)
{
pthread_join(tid[i],NULL);
}
return 0;
}
此时会出现将cout减为负数的情况，这显然是不正确的
原子性的解释
造成上述原因是cout- -这个操作不是原子性的 cout- -需要经过下面的步骤
1.将内存中的cout值读取到cpu上
2.对cout值进行-1.
3.将cout的值写回内存中
设cout值为100
当线程1刚把内存中的cout读到cpu中，此时搞好进行线程切换，这个cout值会作为线程上下文信息被保留下来。线程1认为此时cout值为100
线程2切换回后，当线程2执行时间比较长时，线程2把cout读到cpu中，cout- -执行完后，又将cout写回到内存上，此时cout值变为99。
线程切换回线程1时，线程1的上下文信息加载到cpu中，但这时线程1认为cout为100。所以就会出现两个线程操作的cout的值不一致的错误
3.临界资源的保护(Linux互斥锁pthread_mutex_t)
根据上面的分析，我们知道：
线程与线程之间必须有互斥的约束。一个线程在访问临界资源，此时其他线程不能再访问临界资源，在Linux中这种保护通过互斥锁来实现。当一个线程申请到锁，其他线程就会阻塞等待锁的释放，保护了临界资源
初始化互斥锁(pthread_mutex_init（pthread.h）)
如上图给出了两种初始化pthread_mutex_t的方法，一种是pthread_mutex_init函数初始化
另一种是 pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
参数解释：
mutex：要初始化的互斥锁
attr：互斥锁的属性，一般为NULL默认
返回值：成功返回0，失败返回错误码
互斥锁的销毁(pthread_mutex_destroy（pthread.h）)
参数解释：只需要传入要销毁的互斥锁即可
返回值：成功返回0，失败返回错误码。
临界资源加锁与解锁(pthread_mutex_lock/pthread_mutex_unlock)
注意：加锁有损于性能。
eg:
#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
int cout=100000;
pthread_mutex_t lock;
void*Del(void*meg)
{
int Num=(int)meg;
while(1)
{
pthread_mutex_lock(&lock);//进入临界资源时加锁
if(cout>0)
{
usleep(1000);
cout--;
printf("pthread%d cout=%dn",Num,cout);
pthread_mutex_unlock(&lock);//出临界资源解锁
}
else
{
//如果此时不需要--，此时也要释放锁
pthread_mutex_unlock(&lock);
break;
}
}
}
int main()
{
pthread_t tid[4];
pthread_mutex_init(&lock,NULL);
for(int i=0;i<4;i++)
{
pthread_create(&tid[i],NULL,Del,(void*)i);
}
for(int i=0;i<4;i++)
{
pthread_join(tid[i],NULL);
}
pthread_mutex_destroy(&lock);
return 0;
}
如图：这样cout就不存在负数的情况了。但这样还存在问题，因为线程刚刚将锁释放，这个线程对于锁的竞争比其他线程更强，所以可能存在一个线程使得cout减少到0，这时需要引入同步机制，让每个线程都有机会使得cout-- 。
注意：
1.线程申请到锁后在临界区也可以进行线程切换，即便当前线程被切换其他线程也无法进入临界区
4.锁的原子性分析
如上代码，每个线程的状态只有两种。
1.已经申请到锁 2.已经将锁释放
锁可以多个线程所看到，所以锁首先是临界资源。
锁也需要被保护，所以申请锁的过程就是原子性的
加锁与释放锁的原子性的实现
大多数体系结构提供了exchange或swap指令，用来交换寄存器和内存数据。因为只有一条指令，所以这个过程是原子性的。
加锁与解锁流程图：
5.可重入与线程安全
可重入函数：如果当在一个执行流下在执行这个函数，另一个执行流也执行这个函数。如果运行不会有问题，这时称为这个函数为可重入函数。
线程安全：当在多线程并发执行代码时不会出现不同的结果(常见为全局变量和静态变量等)，称为线程安全
函数可重入则一定是线程安全的，线程安全不一定是可重入的。
一个讨论的是函数，一个讨论的是线程
6.死锁
死锁：线程因为编码失误导致申请的锁没有释放而导致永久等待的情况。
eg:连续申请两次锁。
#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
int cout=1000;
pthread_mutex_t lock;
void*Del(void*meg)
{
int Num=(int)meg;
while(1)
{
pthread_mutex_lock(&lock);//进入临界资源时加锁
pthread_mutex_lock(&lock);//连续申请两次锁导致死锁
if(cout>0)
{
usleep(1000);
cout--;
printf("pthread%d cout=%dn",Num,cout);
pthread_mutex_unlock(&lock);//出临界资源解锁
}
else
{
//如果此时不需要--，此时也要释放锁
pthread_mutex_unlock(&lock);
break;
}
}
}
int main()
{
pthread_t tid[4];
pthread_mutex_init(&lock,NULL);
for(int i=0;i<4;i++)
{
pthread_create(&tid[i],NULL,Del,(void*)i);
}
for(int i=0;i<4;i++)
{
pthread_join(tid[i],NULL);
}
pthread_mutex_destroy(&lock);
return 0;
}
阻塞挂起(资源等待队列)
死锁的必要条件
- 互斥条件：线程A有线程B的锁，线程B有线程A的锁。
- 请求与保持条件：A线程拥有锁但还申请锁
- 不剥夺条件：A线程拥有锁，A线程不会被剥夺
- 循环等待条件：线程A有线程B的锁，线程B有线程A的锁。线程A申请A锁，线程B申请B锁导致死锁。
解除死锁只要破坏死锁的4个必要条件即可