线程之互斥锁与死锁

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/WRNGT/article/details/72866396
互斥锁:
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、例:如下代码:
#include<stdio.h>
#include<pthread.h>
#include<string.h>
#include<sys/types.h>
#include<unistd.h>
int count = 0;

void* pthread_run()
{
    int i = 0;
    int ret = 0;
    while(i < 5000)
    {
        i++;
        ret = count;
        printf("process ID:%d,pthread ID:%lu,count:%d\n",getpid(),pthread_self(),count);
        count = ret + 1;
    }
}

int main()
{
    int ret = 0;
    pthread_t id1;
    pthread_t id2;
    pthread_create(&id1,NULL,&pthread_run,NULL);
    pthread_create(&id2,NULL,&pthread_run,NULL);
    pthread_join(id1,NULL);  //wait
    pthread_join(id2,NULL);
    printf("count: %d\n",count);
    return 0;
}




原本count全局变量+1,加5000次,但是两个线程理应加到10000才正确,但是因为count不是原子性,导致出错;
我们要清楚一个增量操作分为三步骤: 
1)从内存当中读入寄存器 
2)寄存器进行增量操作 
3)写回内存
正因为这三步操作,所以当不同步的时候,第一个线程已经对增量操作了,但是第二个线程读取到的依然是第一个线程增量操作之前的内容。这样就会出现问题,本来应该由1增加到3的,结果变为了由1到2。
要想代码按照我们预期的想法加到10000,必须加互斥锁,保护临界资源:修改上代码如下:
#include<stdio.h>
#include<pthread.h>
#include<string.h>
#include<sys/types.h>
#include<unistd.h>
int count = 0;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

void* pthread_run()
{
    int i = 0;
    int ret = 0;
    while(i < 5000)
    {
        pthread_mutex_lock(&lock);
        i++;
        ret = count;
        printf("process ID:%d,pthread ID:%lu,count:%d\n",getpid(),pthread_self(),count);
        count = ret + 1;
        pthread_mutex_unlock(&lock);
    }
    // sleep(200);
    //return (void*)5;
}

int main()
{
    int ret = 0;
    pthread_t id1;
    pthread_t id2;
    pthread_create(&id1,NULL,&pthread_run,NULL);
    pthread_create(&id2,NULL,&pthread_run,NULL);
    pthread_join(id1,NULL);  
    pthread_join(id2,NULL);
    printf("count: %d\n",count);
    return 0;
}
添加互斥锁保证其原子性,结果正确:



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

预防死锁:

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

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

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

避免死锁:

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

检测死锁

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

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

解除死锁:

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

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

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




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