线程之互斥锁与死锁

最新推荐文章于 2024-07-09 15:38:01 发布

优秀005

最新推荐文章于 2024-07-09 15:38:01 发布

阅读量1.3w

点赞数 4

分类专栏： linux 文章标签： linux 线程互斥锁编程

本文链接：https://blog.csdn.net/WRNGT/article/details/72866396

版权

linux 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

互斥锁：

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 ，在第二次调用时，由于锁已经被占用，该线程会挂起等待别的线程释放锁，然而锁正是被自己占用着的，该线程又被挂起而没有机会释放锁，因此就永远处于挂起等待状态了（一个资源程序比较长开始使用了这把锁，中途忘记这把锁被使用，再次上锁；或者在这个资源程序中调用其他函数也使用了这把锁）

另一种：若线程 A 获得了锁 1 ，线程 B 获得了锁 2 ，这时线程 A 调用 lock 试图获得锁 2 ，结果是需要挂起等待线程 B 释放锁 2 ，而这时线程 B 也调用 lock 试图获得锁 1 ，结果是需要挂起等待线程 A 释放锁 1 ，于是线程 A 和 B 都永远处于挂起状态了。

2、死锁产生的四个必要条件：

（1）互斥条件：一个资源每次只能被一个进程使用

（2）请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
（3）不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
（4）循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，而只要上述条件之一不满足，就不会发生死锁。

3、如何避免死锁：

预防死锁：

资源一次性分配：（破坏请求和保持条件）

可剥夺资源：即当某进程新的资源未满足时，释放已占有的资源（破坏不可剥夺条件）

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

避免死锁:

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

检测死锁

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

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

解除死锁:

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

剥夺资源：从其它进程剥夺足够数量的资源给死锁进程，以解除死锁状态；

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