linux 线程 死锁

死锁：🔴⚫🟤🟣🔵🟢🟡🟠

　　有时，一个线程需要同时访问两个或更多不同的共享资源，而每个资源又都由不同的互斥量管理。当超过一个线程加锁同一组互斥量时，就有可能发生死锁。

　　两个或两个以上的进程在执行过程中，因争夺共享资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁。

　　死锁的几种场景：

　　　　🔴 忘记释放锁

　　　　🔴 重复加锁

　　　　🔴 多线程多锁，抢占锁资源(互相等待  A持有资源1 等待资源2  B持有资源2 等待资源1)

主代码：

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
int tickets = 500;
//创建一个互斥量
pthread_mutex_t mutex;//全局变量
void * sellticket(void * arg)
{
    //A B C A先进 然后加锁 执行while 解锁 B C A都有机会执行代码区  有解锁后才可以进行执行 
    //卖票
    while(1)
    { 
        //加锁
        pthread_mutex_lock(&mutex);
        if(tickets > 0)
        {
            usleep(6000);
            printf("%ld 正在卖第 %d 张门票\n",pthread_self(),tickets);
            tickets--;
        }
        else 
        {
            // = 0 解锁
            pthread_mutex_unlock(&mutex);
            break;
        }
        //解锁  
        pthread_mutex_unlock(&mutex);
    } 
    return NULL;
}
int main()
{
    //初始化
    pthread_mutex_init(&mutex, NULL);
    //创建3个子线程
    pthread_t tid1,tid2,tid3;
    pthread_create(&tid1, NULL, sellticket, NULL);
    pthread_create(&tid2, NULL, sellticket, NULL);
    pthread_create(&tid3, NULL, sellticket, NULL);
    //回收子线程的资源, 阻塞
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    pthread_join(tid3,NULL);
    pthread_exit(NULL);//退出主线程
    //释放互斥量资源
    pthread_mutex_destroy(&mutex);
    return 0;
}

1.忘记释放锁：

void * sellticket(void * arg)
{
    while(1)
    { 
        pthread_mutex_lock(&mutex);
        if(tickets > 0)
        {
            usleep(6000);
            printf("%ld 正在卖第 %d 张门票\n",pthread_self(),tickets);
            tickets--;
        }
        else 
        {
            // = 0 解锁
            pthread_mutex_unlock(&mutex);
            break;
        }
        //解锁  
        //pthread_mutex_unlock(&mutex);//忘记释放锁   会导致死锁,程序不正常执行
    } 
    return NULL;
}

2.重复加锁

void * sellticket(void * arg)
{
    while(1)
    { 
        pthread_mutex_lock(&mutex);//加锁
        pthread_mutex_lock(&mutex);//重复加锁
        if(tickets > 0)
        {
            usleep(6000);
            printf("%ld 正在卖第 %d 张门票\n",pthread_self(),tickets);
            tickets--;
        }
        else 
        {
            pthread_mutex_unlock(&mutex);// = 0 解锁
            break;
        }
        pthread_mutex_unlock(&mutex);//解锁
        pthread_mutex_unlock(&mutex);//重复解锁 但用不到  程序阻塞
    } 
    return NULL;
}

3.多线程多锁：

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <string.h> 
//创建两个互斥量
pthread_mutex_t mutex1,mutex2;
void * workA(void * arg)//arg:argument 传参
{
    pthread_mutex_lock(&mutex1);
    sleep(1);
    pthread_mutex_lock(&mutex2);
    printf("workA...\n");
    pthread_mutex_unlock(&mutex2);
    pthread_mutex_unlock(&mutex1);
    return NULL;
}
void * workB(void * arg)
{
    pthread_mutex_lock(&mutex2);
    sleep(1);
    pthread_mutex_lock(&mutex1);
    printf("workB...\n");
    pthread_mutex_unlock(&mutex1);
    pthread_mutex_unlock(&mutex2);
    return NULL;
}
int main()
{
    // 初始化两个互斥量
    pthread_mutex_init(&mutex1,NULL);
    pthread_mutex_init(&mutex2,NULL);
    //创建2个子线程
    pthread_t tid1,tid2;
    pthread_create(&tid1,NULL,workA,NULL);
    pthread_create(&tid2,NULL,workB,NULL);
    //回收子线程资源
     pthread_join(tid1,NULL);
     pthread_join(tid2,NULL);
    //释放互斥量资源
    pthread_mutex_destroy(&mutex1);
    pthread_mutex_destroy(&mutex2);
    return 0;
}