互斥锁与死锁简单介绍(转)

版权声明:转载注明出处即可 https://blog.csdn.net/Geomancerest/article/details/80573541
互斥锁:
1、互斥锁基本原理:
     互斥锁是一个二元变量,其状态为开锁(允许0)和上锁(禁止1),将某个共享资源与某个特定互斥锁在逻辑上绑定(要申请该资源必须先获取锁)。
     (1)访问公共资源前,必须申请该互斥锁,若处于开锁状态,则申请到锁对象,并立即占有该锁,以防止其他线程访问该资源;如果该互斥锁处于锁定状态,则阻塞当前线程。
     (2)只有锁定该互斥锁的进程才能释放该互斥锁,其他线程试图释放无效。
2、初始化互斥锁:
     使用之前,需要定义互斥锁,使用函数:pthread_mutex_t lock;进行定义。
     初始化锁:
     extern int    pthread_mutex_init(pthread_mutex_t *_mutex,_const pthread_mutex_mutexattr_t* _mutexattr)
          第一个参数mutex指要初始化的互斥锁的指针。
          第二个参数mutexattr是指向对象的指针,如果该属性为空,则使用默认的属性。
          全用宏PTHREAD_MUTEX_INITIALIZER来初始化静态分配的互斥锁(全局锁);
3、申请互斥锁
     如果一个线程要占用共享资源,必须先申请对应互斥锁,使用函数:
extern int pthread_mutex_lock(pthread_mutex* _mutex)以阻塞方式申请互斥锁;
extern int pthread_mutex_trylock(pthread_mutex* _mutex)以非阻塞方式申请互斥锁;
    若申请成功,返回0,否则,返回一个错误编号。
     <注:参数都是要申请互斥锁的指针>
4、释放互斥锁
     释放互斥锁用函数:
     extern int pthread_mutex_unlock(pthread_mutex_t* _mutex)
     参数mutex是指向要解锁的互斥锁的指针
     释放只能由占有该互斥锁的线程完成,如果释放成功,返回0,失败返回错误编号。
     unlock中的释放锁操作同样只用一条指令实现,以保证它的原子性。
5、例:如下代码:
  1. #include<stdio.h>  
  2. #include<pthread.h>  
  3. #include<string.h>  
  4. #include<sys/types.h>  
  5. #include<unistd.h>  
  6. int count = 0;  
  7.   
  8. void* pthread_run()  
  9. {  
  10.     int i = 0;  
  11.     int ret = 0;  
  12.     while(i < 5000)  
  13.     {  
  14.         i++;  
  15.         ret = count;  
  16.         printf("process ID:%d,pthread ID:%lu,count:%d\n",getpid(),pthread_self(),count);  
  17.         count = ret + 1;  
  18.     }  
  19. }  
  20.   
  21. int main()  
  22. {  
  23.     int ret = 0;  
  24.     pthread_t id1;  
  25.     pthread_t id2;  
  26.     pthread_create(&id1,NULL,&pthread_run,NULL);  
  27.     pthread_create(&id2,NULL,&pthread_run,NULL);  
  28.     pthread_join(id1,NULL);  //wait  
  29.     pthread_join(id2,NULL);  
  30.     printf("count: %d\n",count);  
  31.     return 0;  
  32. }  




原本count全局变量+1,加5000次,但是两个线程理应加到10000才正确,但是因为count不是原子性,导致出错;
我们要清楚一个增量操作分为三步骤: 
1)从内存当中读入寄存器 
2)寄存器进行增量操作 
3)写回内存
正因为这三步操作,所以当不同步的时候,第一个线程已经对增量操作了,但是第二个线程读取到的依然是第一个线程增量操作之前的内容。这样就会出现问题,本来应该由1增加到3的,结果变为了由1到2。
要想代码按照我们预期的想法加到10000,必须加互斥锁,保护临界资源:修改上代码如下:
  1. #include<stdio.h>  
  2. #include<pthread.h>  
  3. #include<string.h>  
  4. #include<sys/types.h>  
  5. #include<unistd.h>  
  6. int count = 0;  
  7. pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;  
  8.   
  9. void* pthread_run()  
  10. {  
  11.     int i = 0;  
  12.     int ret = 0;  
  13.     while(i < 5000)  
  14.     {  
  15.         pthread_mutex_lock(&lock);  
  16.         i++;  
  17.         ret = count;  
  18.         printf("process ID:%d,pthread ID:%lu,count:%d\n",getpid(),pthread_self(),count);  
  19.         count = ret + 1;  
  20.         pthread_mutex_unlock(&lock);  
  21.     }  
  22.     // sleep(200);  
  23.     //return (void*)5;  
  24. }  
  25.   
  26. int main()  
  27. {  
  28.     int ret = 0;  
  29.     pthread_t id1;  
  30.     pthread_t id2;  
  31.     pthread_create(&id1,NULL,&pthread_run,NULL);  
  32.     pthread_create(&id2,NULL,&pthread_run,NULL);  
  33.     pthread_join(id1,NULL);    
  34.     pthread_join(id2,NULL);  
  35.     printf("count: %d\n",count);  
  36.     return 0;  
  37. }  
添加互斥锁保证其原子性,结果正确:



死锁:
典型的两种死锁情形: 
(一)线程自己将自己锁住 
一般情况下,如果同一个线程先后两次调用lock,在第二次调⽤用时,由于锁已经被占用,该线程会挂起等待占用锁的线程释放锁,然而锁正是被自己占用着的,该线程又被挂起而没有机会释放锁,因此 就永远处于挂起等待状态了,于是就形成了死锁(Deadlock)。 
(二)多线程抢占锁资源被困 
又如线程A获 得了锁1,线程B获得了锁2,这时线程A调用lock试图获得锁2,结果是需要挂起等待线程B释放 锁2,而这时线程B也调用lock试图获得锁1,结果是需要挂起等待线程A释放锁1,于是线程A和B都 永远处于挂起状态了,死锁再次形成。
2、死锁产生的四个必要条件:
(1) 互斥条件:一个资源每次只能被一个进程使用
(2) 请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放。
(3) 不剥夺条件:进程已获得的资源,在末使用完之前,不能强行剥夺。
(4) 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
这四个条件是死锁的必要条件,只要系统发生死锁,这些条件必然成立,而只要上述条件之一不满足,就不会发生死锁。
3、如何避免死锁:

预防死锁:

资源一次性分配:(破坏请求和保持条件)

可剥夺资源:即当某进程新的资源未满足时,释放已占有的资源(破坏不可剥夺条件)

资源有序分配法:系统给每类资源赋予一个编号,每一个进程按编号递增的顺序请求资源,释放则相反(破坏环路等待条件)

避免死锁:

预防死锁的几种策略,会严重地损害系统性能。因此在避免死锁时,要施加较弱的限制,从而获得 较满意的系统性能。由于在避免死锁的策略中,允许进程动态地申请资源。因而,系统在进行资源分配之前预先计算资源分配的安全性。若此次分配不会导致系统进入不安全状态,则将资源分配给进程;否则,进程等待。其中最具有代表性的避免死锁算法是银行家算法。

检测死锁

首先为每个进程和每个资源指定一个唯一的号码;

然后建立资源分配表和进程等待表,例如:

解除死锁:

当发现有进程死锁后,便应立即把它从死锁状态中解脱出来,常采用的方法有:

剥夺资源:从其它进程剥夺足够数量的资源给死锁进程,以解除死锁状态;

撤消进程:可以直接撤消死锁进程或撤消代价最小的进程,直至有足够的资源可用,死锁状态.消除为止;所谓代价是指优先级、运行代价、进程的重要性和价值等。
展开阅读全文

没有更多推荐了,返回首页