以下是《Unix 环境高级编程》中的一个实例：
这个例子用以描述两个互斥量的使用方法。当同时使用两个互斥量时，总是让他们用相同的顺序加锁，以避免死锁。第二个互斥量维护一个用于追踪foo数据结构的散列列表。这样hashlock互斥量保护foo数据结构中的fh散列表和f_next散列链字段。foo结构中的f_lock互斥量保护对foo结构中的其他字段访问。

#include 

#include 



#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);

	}

}

你的代码是错的，我翻了翻书，里面的代码是这样：

fp->f_next = fh[idx];

fh[idx] = fp;