互斥量和避免死锁

2017-03-15

互斥量

互斥变量是用pthread_mutex_t数据类型表示的,在使用互斥变量之前,必须首先对它进行初始化,可以把它设置为常量PTHREAD_MUTEX_INITIALIZER(只适用于静态分配的互斥量),也可以调用pthread_mutex_init进行初始化,如果动态分配互斥量,在释放内存前需要调用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);
int pthread_mutex_lock(pthread_mutex_t* mutex);
int pthread_mutex_trylock(pthread_mutex_t* mutex); //不阻塞,只尝试加锁,若失败返回EBUSY.
int pthread_mutex_unlock(pthread_mutex_t* mutex);

死锁

如果线程试图对同一个互斥量加锁两次,那么它自身就会陷入死锁状态,但是使用互斥量时,还有其他不太明显的方式也能产生死锁,例如,程序中使用一个以上的互斥量时,如果允许一个线程一直占用第一个互斥量,并且在试图锁住第二个互斥量时处于阻塞状态,但是拥有第二个互斥量的线程也在师徒锁住第一个互斥量.因为两个线程都在相互请求另一个线程拥有的资源,所以这两个线程都无法向前运行,于是就产生死锁.
解决办法就是控制互斥量加锁顺序,比如同时要对互斥量A和B加锁,如果所有线程总是在对B加锁前锁住A,那么使用这两个就不会产生死锁.可以参考下面的例子:

#include<stdlib.h>
#include<pthread.h>
const int NHASH=29;
#define HASH(id) (((unsigned long)id)%NHASH)
pthread_mutex_t hashlock=PTHREAD_MUTEX_INITIALIZER;
struct foo{
	int f_count;
	pthread_mutex_t f_lock;
	int f_id;
	struct foo* f_next;//protected by hashlock
};
struct foo* fh[NHASH];
struct foo* foo_alloc(int id){
	struct foo* fp;
	int idx;
	if((fp=(struct foo*)malloc(sizeof(struct foo)))!=NULL){
		fp->f_count=1;
		fp->f_id=id;
		if(pthread_mutex_init(&fp->f_lock,NULL)!=0){
			free(fp);
			return NULL;
		}
		idx=HASH(id);
		pthread_mutex_lock(&hashlock);
		fp->f_next=fh[idx];
		fh[idx]=fp;
		pthread_mutex_lock(&fp->f_lock);
		pthread_mutex_unlock(&hashlock);
	}
	return fp;
}
void foo_hold(struct foo* fp){
	pthread_mutex_lock(&fp->f_lock);
	fp->f_count++;
	pthread_mutex_unlock(&fp->f_lock);
}
struct foo* foo_find(int id){
	struct foo* fp;
	pthread_mutex_lock(&hashlock);
	for(fp=fh[HASH(id)];fp!=NULL;fp=fp->f_next){
		if(fp->f_id==id){
			fp->f_count++;
			break;
		}
	}
	pthread_mutex_unlock(&hashlock);
	return fp;
}
//第一个版本的释放函数,严格按照每种互斥量的功能来锁住临界区,由于需要考虑互斥量使用顺序,会导致代码变得复杂.(foo_rele函数中先上锁在观察是否需要修改fh散列表,如果需要修改则必须先解锁在按顺序上锁)
void foo_rele(struct foo* fp){
	struct foo* tfp;
	int idx;
	pthread_mutex_lock(&fp->f_lock);
	if(fp->f_count==1){
		pthread_mutex_unlock(&fp->f_lock);
		pthread_mutex_lock(&hashlock);
		pthread_mutex_lock(&fp->f_lock);
		if(fp->f_count!=1){
			fp->f_count--;
			pthread_mutex_unlock(&fp->f_lock);
			pthread_mutex_unlock(&hashlock);
			return;
		}else{
			idx=HASH(fp->f_id);
			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(&fp->f_lock);
		pthread_mutex_unlock(&hashlock);
		pthread_mutex_destory(&fp->f_lock);
		free(fp);
	}else{
		fp->f_count--;
		pthread_mutex_unlock(&fp->f_lock);
	}
}
//第二个版本的释放函数.直接用hashlock来锁住对fp的操作,避免了两个互斥量使用的顺序问题.简化了代码.但是线程阻塞的概率会更大,因为hashlock使用的范围更大.需要权衡两者的使用.
void foo_rele2(struct foo* fp){
	struct foo* tfp;
	int idx;
	pthread_mutex_lock(&hashlock);
	if(--fp->f_count==0){
		idx=HASH(fp->f_id);
		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_destory(&fp->f_lock);
		free(fp);
	}else
		pthread_mutex_unlock(&hashlock);
}