APUE之线程（四）

线程同步：

        线程同步问题，可以说是每一本经典的操作系统教程都能会提到。简单的说就是对于一个变量，如果一个进程可以修改，其他的进程也可以读取或者修改这个变量的时候，就需要对这些进程进行同步，以确保他们在访问变量存储的内容的时候不会访问到无效的数据。

互斥量：

        互斥变量的数据类型用pthread_mutex_t数据类型来表示，使用前必须要初始化，可以把他设置位常量，PTHREAD_MUTEX_INITIALIZER（只对静态分配的互斥量），也可以通过调用pthread_mutex_init()函数来进行初始化。如果动态分配互斥量（例如通过malloc()），那么在释放内存前需要调用pthread_mutex_destory。

#include <pthread.h>int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);int pthread_mutex_destory(pthread_mutex_t *mutex);

        要用默认的属性进行初始化互斥量，只需要把attr设置为NULL。

        对互斥量进行加锁，需要调用pthread_mutex_lock，如果互斥量已经上锁，调用线程将阻塞知道互斥量被解锁。解锁互斥量用pthread_mutex_unlock。

#Include <pthread.h>int pthread_mutex_lock(pthread_mutex_t *mutex);int pthread_mutex_trylock(pthread_mutex_t *mutex);int pthread_mutex_unlock(pthread_mutex_t *mutex);

        如果线程不希望被阻塞，那么他可以使用pthread_mutex_trylock()尝试对互斥量进行加锁。如果调用pthread_mutex_trylock()时互斥量处于未锁住的状态，那么这个函数将锁住互斥量，不会出现阻塞并返回0，否则pthread_mutex_trylock()就会失败，不能锁住互斥量，返回EBUSY。

下面的代码用于保护某个数据结构的互斥量。

/* *Name : list11_5.c *Author : Lniper *Date : 2016-02-17 *Aim : Using the mutex to protect the data struct. */#include <stdlib.h>#include <pthread.h>struct foo{int f_count;pthread_mutex_t f_lock;};struct foo *foo_alloc(void){/* allocate the object */struct foo *fp;if((fp = malloc(sizeof(struct foo))) != NULL){fp->f_count = 1;if(pthread_mutex_init(&fp->f_lock, NULL) != 0){free(fp);return(NULL);}/* ...continue initialization ... */}return (fp);}void foo_hold(strcut foo *fp){/* add a reference to the object */pthread_mutex_lock(&fp->f_lock);fp->f_count++;pthread_mutex_unlock(&fp->f_lock);}void foo_rele(struct foo *fp){/* release a reference to the object */pthread_mutex_lock(&fp->f_lock);if(--fp->f_count == 0){/* last reference */pthread_mutex_unlock(&fp->f_lock);pthread_mutex_destory(&fp->f_lock);free(fp);}else{pthread_mutex_unlock(&fp->f_lock);}}

        以上可以看出在foo_alloc函数将引用计数初始化为1是没有必要加锁，因为在这个操作前分配线程是唯一引用该对象的线程。但是在这之后如果要将该对象放到一个列表中，那么他就有可能被别的线程发现，因此需要首先对他加锁。

总结一下，线程在使用对象前需要对对象的引用计数加1，当对象使用完毕，需要对引用计数减1。当最后一个引用被释放的时候，对象所占用的内存空间就被释放了。

避免死锁：

        如果线程对同一个互斥量加锁两次，那么自身就会陷入死锁状态。比如说，程序中使用多个互斥量时，如果允许一个线程一直占用第一个互斥量，并且在试图锁住第二个互斥量的时候处于阻塞的状态，但是拥有第二个互斥量的线程试图锁住第一个互斥量的时候，这个时候如果没有“外力”的介入打破这种僵局就会产生死锁。

        下面这个例子用以描述互斥量的使用方法，当同时需要两个互斥量的时候，总是让他们以相同的顺序进行加锁，从而来避免死锁的发生。第二个互斥量维护者一个用于跟踪foo数据结构的散列表。这样hashlock互斥量保护的foo结构中的fh散列表和f_next散列链字段。foo结构中的f_lock互斥量保护对foo结构中的其他字段的访问。

/* *Name : list11_6.c *Author : Lniper *Date : 2016-02-17 *Aim : Using double mutexs. */#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;pthread_mutex_lock(&fp->f_lock);pthread_mutex_unlock(&hashlock);/* ...continue initialization ... */pthread_mutex_unlock(&fp->f_lock);}return (fp);}void foo_hold(strcut 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);}}

       这里维护两个互斥量，一个是全局互斥量hashlock，一个是结构体内部的互斥量f_lock，全局互斥量是hash表自身的互斥量，每次先加锁全局，在加锁局部的互斥量从而来避免死锁的发生。