linux线程的死锁

        多个线程并发同一段代码时，不会出现不同的结果。常见对全局变量或者静态变量进行操作，并且没有锁保护的情况下，会出现线程不安全的问题。所以在进行多线程操作时会对线程进行加锁，如果线程管理的共享资源太多时，就会需要多把锁，而多把锁在使用时可能会由于使用不当而造成死锁。

一、什么是死锁

• 一般情况下,如果同一个线程先后两次调用lock，在第一次调用时，由于锁已经被占,该线程会挂起等待别的线程释放锁,然而锁正是被自己占着的，该线程又被挂起，没有机会释放锁,因此，就永远处于挂起等待状态了，这叫做死锁(Deadlock)。
• 另种典型的死锁情形是这样:线程A获得了锁1，线程B获得了锁2，这时线程A调用lock试图获得锁2,结果是需要挂起等待线程B释放锁2，而这时线程B也调用lock试图获得锁1，结果是需要挂起等待线程A释放锁1，于是线程A和B都永远处于挂起状态了。
   

所谓死锁，是指多个线程在运行过程中因争夺资源而造成的一种僵局(DeadlyEmbreace)即互相等待的现象，当线程处于这种僵持状态时，若无外力作用，它们都将无法向前推进。

二、死锁产生的原因

1、系统资源的竞争
通常系统中拥有的不可剥夺资源，其数量不足以满足多个进程运行的需要，使得进程在 运行过程中，会因争夺资源而陷入僵局，如磁带机、打印机等。只有对不可剥夺资源的竞争 才可能产生死锁，对可剥夺资源的竞争是不会引起死锁的。
2、进程推进顺序非法
 进程在运行过程中，请求和释放资源的顺序不当，也同样会导致死锁。例如，并发进程 P1、P2分别保持了资源R1、R2，而进程P1申请资源R2，进程P2申请资源R1时，两者都 会因为所需资源被占用而阻塞。
信号量使用不当也会造成死锁。进程间彼此相互等待对方发来的消息，结果也会使得这些进程间无法继续向前推进。例如，进程A等待进程B发的消息，进程B又在等待进程A 发的消息，可以看出进程A和B不是因为竞争同一资源，而是在等待对方的资源导致死锁。

三、死锁产生的必要条件

虽然线程在运行过程中可能发生死锁，但死锁的发生也必须具备一定的条件。死锁的发生必须具备下列四个必要条件。

1. 互斥条件：指进程对所分配到的资源进行排它性使用，即在一段时间内某资源只由一个进程占用。如果此时还有其它进程请求资源，则请求者只能等待，直至占有资源的进程用毕释放。
2. 请求和保持条件：指进程已经保持至少一个资源，但又提出了新的资源请求，而该资源已被其它进程占有，此时请求进程阻塞，但又对自己已获得的其它资源保持不放。
3. 不剥夺条件：指进程已获得的资源，在未使用完之前，不能被剥夺，只能在使用完时由自己释放。
4. 环路等待条件：指在发生死锁时，必然存在一个进程——资源的环形链，即进程集合{P0，P1，P2，···，Pn}中的P0正在等待一个P1占用的资源；P1正在等待P2占用的资源，……，Pn正在等待已被P0占用的资源。
    

四、死锁的避免方法

• 破坏死锁的必要条件
• 加锁顺序（线程按照一定的顺序加锁即按相同的次序锁定相应的共享资源）
• 加锁时限（线程尝试获取锁的时候加上一定的时限，超过时限则放弃对该锁的请求，并释放自己占有的锁）使用函数 pthread_mutex_trylock()，它是函数 pthread_mutex_lock() 的非阻塞版本。如果线程不希望被阻塞，它可以使用pthread_mutex_trylock尝试对互斥量进行加锁。如果调用pthread_mutex_trylock时互斥量处于未锁住状态，那么pthread_mutex_trylock将锁住互斥量，不会出现阻塞并返回0，否则pthread_mutex_trylock就会失败，不能锁住互斥量，而返回EBUSY。

五、死锁案例

代码：

#include <stdio.h>
#include <pthread.h>

pthread_mutex_t mutex;
pthread_mutex_t mutex2;

void *func1(void *arg)
{
    int i;
    pthread_mutex_lock(&mutex);
    sleep(1);
    pthread_mutex_lock(&mutex2);

    for(i=0;i<3;i++)
    {
        printf("t1:%ld pthread is creat\n",(unsigned long)pthread_self());
        printf("t1:param is %d\n", *((int *)arg));
        sleep(1);
    }
    pthread_mutex_unlock(&mutex);
    pthread_mutex_unlock(&mutex2);
}

void *func2(void *arg)
{
    pthread_mutex_lock(&mutex2);
    sleep(1);
    pthread_mutex_lock(&mutex);

    printf("t2:%ld pthread is creat\n",(unsigned long)pthread_self());
    printf("t2:param is %d\n", *((int *)arg));

    pthread_mutex_unlock(&mutex);
    pthread_mutex_unlock(&mutex2);

}

void *func3(void *arg)
{
    pthread_mutex_lock(&mutex);

    printf("t3:%ld pthread is creat\n",(unsigned long)pthread_self());
    printf("t3:param is %d\n", *((int *)arg));

    pthread_mutex_unlock(&mutex);
}

int main()
{

    int ret;
    int param = 100;
    pthread_t t1;
    pthread_t t2;
    pthread_t t3;

    pthread_mutex_init(&mutex,NULL);
    pthread_mutex_init(&mutex2,NULL);

    ret = pthread_create(&t1, NULL, func1, (void *)&param);
    if(ret == 0){

           printf("main:creat t1 success\n");
    }

    ret = pthread_create(&t2, NULL, func2, (void *)&param);
    if(ret == 0){

           printf("main:creat t2 success\n");
    }

    ret = pthread_create(&t3, NULL, func3, (void *)&param);
    if(ret == 0){

           printf("main:creat t3 success\n");
    }

    printf("main:%ld\n",(unsigned long)pthread_self());

    pthread_join(t1,NULL);
    pthread_join(t2,NULL);
    pthread_join(t3,NULL);

    pthread_mutex_destroy(&mutex);
    pthread_mutex_destroy(&mutex2);

    return 0;

}

结果：

CLC@Embed_Learn:~/thread$ ./a.out 
main:creat t1 success
main:creat t2 success
main:creat t3 success
main:140100565542656
^C
CLC@Embed_Learn:~/thread$ ./a.out 
main:creat t1 success
main:creat t2 success
main:creat t3 success
main:140629535221504
t3:140629510149888 pthread is creat
t3:param is 100
^C
CLC@Embed_Learn:~/thread$ ./a.out 
main:creat t1 success
main:creat t2 success
main:creat t3 success
main:140159975626496
t3:140159950554880 pthread is creat
t3:param is 100
^C
CLC@Embed_Learn:~/thread$ 

通过程序及结果分析，线程1先使用锁1进行了加锁，睡眠1s使用锁2，线程2先使用锁2对线程进行加锁，睡眠1s后使用锁1。当线程1运行到使用锁2时，由于锁2被线程2先占用，所以就阻塞在使用锁2这里，而线程2在运行到使用锁1时，由于锁1先被线程1所占用，所以线程2就阻塞在这里，这两个线程都拿不到另外一把锁，都在等待对方释放锁，这种互相等待的现象，就造成了死锁的现象，最终程序运行的结果就是谁也执行不了，互相卡死。但是我们多执行几次，线程3是有正常执行的情况出现的，这是因为线程3只使用一个锁，在线程竞争中如果线程3竞争成功拿到锁1先得到执行，那么线程3是能正常执行的，在执行完后释放锁，但是线程1和线程2则阻塞无法执行。