引子：线程死锁曾是多少程序员的噩梦，每每为此食不甘味，夜不成寐，一句话：苦不堪言。本文从几个场景入手，试图解开产生死锁的原因之谜。

教科书：说的很具体，理解很抽象

　　关于死锁产生的原因《操作系统》中有比较好的说明：

　　（1）因为系统资源不足。

　　（2）进程运行推进的顺序不合适。

　　（3）资源分配不当等。

　　关于死锁出现的必要条件也有比较具体的说明：

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

　　（2）请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。

　　（3）不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。

　　（4）循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

　　这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，这也为我们实际应用中定位死锁问题，提供了路由。

情景一、不加锁，两线程访问，变量访问示例

　　关于死锁，有锁才能死，如果我们不加锁，自然不会发生死锁，但是如果不加锁，对资源的访问，将会发生什么情况呢。不妨看下面的例子：

　　当两个线程读写相同变量时，线程A读取变量然后给予变量赋予一个新的值，但是写操作需要两个存储器周期。当线程B在这两个存储器周期中间读取这个相同变量时，它就会得到不一致的值。这就是为什么要对多线程资源访问进行加锁，加锁以后的访问顺序就变成了顺序访问，从而可以避免资源的不一致访问。

情景二、不加锁，多线程访问，增量操作示例

　　当两个或多个线程试图在同一时间修改同一个变量时，如果不加锁也会出现数据资源不一致的情况。如下图所示：

　　我们可以看到，增量操作分为三个步骤进行：（1）从内存单元读入寄存器。（2）从寄存器中进行变量值的增加。（3）把新的值写回内存单元。如果两个线程试图同时对统一变量执行增量操作时，结果可能出现不一致。变量可能比原来增加了1，也可能增加了2，具体是1，还是2取决于第二个线程读取变量时获得的值是5还是6。这里面有一个前提就是变量增加的操作不是原子操作，这是因为现代计算机系统中，存储器访问需要多个总线周期，多处理器的总线周期通常在多个处理器上是交叉的，所以无法保证数据时顺序一致的。

情景三、互斥锁，多变量部分锁

　　以上示例已经讲明了我们为何需要线程锁，不加锁将会导致数据资源访问的不一致。可是加锁后，如果存在满足死锁的必要条件，又会产生死锁，我们该怎么办呢？不妨先来看一个示例：

#include <stdlib.h>
#include <pthread.h>

#define NHASH 29
#define HASH(fp) (((unsigned long)fp)%NHASH)

struct foo *fh[NHASH];

pthread_mutex_t hashlock = PTHREAD_MUTEX_INITIALIZER;

struct foo {
    int             f_count;
    pthread_mutex_t f_lock;
    struct foo     *f_next; /* protected by hashlock */
    int             f_id;
    /* ... more stuff here ... */
};

struct foo *
foo_alloc(void) /* allocate the object */
{
    struct foo    *fp;
    int            idx;

    if ((fp = malloc(sizeof(struct foo))) != NULL) {
        fp->f_count = 1;
        if (pthread_mutex_init(&fp->f_lock, NULL) != 0) {
            free(fp);
            return(NULL);
        }
        idx = HASH(fp);
        pthread_mutex_lock(&hashlock);
        fp->f_next = fh[idx];
        fh[idx] = fp->f_next;
        pthread_mutex_lock(&fp->f_lock);
        pthread_mutex_unlock(&hashlock);
        /* ... continue initialization ... */
        pthread_mutex_unlock(&fp->f_lock);
    }
    return(fp);
}
//增加
void
foo_hold(struct foo *fp) /* add a reference to the object */
{
    pthread_mutex_lock(&fp->f_lock);
    fp->f_count++;
    pthread_mutex_unlock(&fp->f_lock);
}
//查找已经对象
struct foo *
foo_find(int id) /* find an existing object */
{
    struct foo    *fp;
    int            idx;

    idx = HASH(fp);
    pthread_mutex_lock(&hashlock);
    for (fp = fh[idx]; fp != NULL; fp = fp->f_next) {
        if (fp->f_id == id) {
            foo_hold(fp);
            break;
        }
    }
    pthread_mutex_unlock(&hashlock);
    return(fp);
}
//减小
void
foo_rele(struct foo *fp) /* release a reference to the object */
{
    struct foo    *tfp;
    int            idx;

    pthread_mutex_lock(&fp->f_lock);
    if (fp->f_count == 1) { /* last reference */
        pthread_mutex_unlock(&fp->f_lock);　　//如果不解锁会怎么样呢？
        pthread_mutex_lock(&hashlock);　　　　//如果顺序发生变化呢？
        pthread_mutex_lock(&fp->f_lock);
        /* need to recheck the condition */
        if (fp->f_count != 1) {
            fp->f_count--;
            pthread_mutex_unlock(&fp->f_lock);
            pthread_mutex_unlock(&hashlock);
            return;
        }
        /* remove from list */
        idx = HASH(fp);
        tfp = fh[idx];
        if (tfp == fp) {
            fh[idx] = fp->f_next;
        } else {
            while (tfp->f_next != fp)
                tfp = tfp->f_next;
            tfp->f_next = fp->f_next;
        }
        pthread_mutex_unlock(&hashlock);
        pthread_mutex_unlock(&fp->f_lock);
        pthread_mutex_destroy(&fp->f_lock);
        free(fp);
    } else {
        fp->f_count--;
        pthread_mutex_unlock(&fp->f_lock);
    }
}

以上代码注意加锁的顺序，如果顺序错了，则会有可能出现死锁。