linux基础编程 多线程中的互斥锁 pthread_mutex_lock

pthread_mutex.h头文件

#ifndef __SEM_UTIL_H__
#define __SEM_UTIL_H__

typedef void* SemHandl_t;

SemHandl_t MakeSem(); ///< Initialize the semaphore.
int SemRelease(SemHandl_t hndlSem); ///< Unlock the semaphore.
int SemWait(SemHandl_t hndlSem); ///< Lock the semaphore.
int DestroySem(SemHandl_t hndlSem); ///< Destory the semaphore.


#endif

pthread_mutex.c源文件

/*
互斥锁用来保证一段时间内只有一个线程在执行一段代码。
必要性显而易见：假设各个线程向同一个文件顺序写入数据，
最后得到的结果一定是灾难性的。
*/
#include 
#include 
#include 
#include 

#include "pthread_mutex.h"

#define __DEBUG
#ifdef __DEBUG
#define DBG(fmt,args...) fprintf(stdout,  fmt,  ##args)
#else
#define DBG(fmt,args...)
#endif
#define ERR(fmt,args...) fprintf(stderr,  fmt,  ##args)

/*线程互斥锁初始化*/
SemHandl_t MakeSem()
{
	SemHandl_t hndlSem = malloc(sizeof(pthread_mutex_t));
	if(hndlSem == NULL){
		ERR("Not enough memory!!\n");
		return NULL;
	}
	/* Initialize the mutex which protects the global data */
	if(pthread_mutex_init(hndlSem, NULL) != 0){
		ERR("Sem init faill!!\n");
		free(hndlSem);
		return NULL;
	}
	return hndlSem;
}

/*线程互斥锁释放*/
int SemRelease(SemHandl_t hndlSem)
{
	if(hndlSem == NULL){
		ERR("SemRelease: Invalid Semaphore handler\n");
		return -1;
	}
	return pthread_mutex_unlock(hndlSem);
}

/*等待*/
int SemWait(SemHandl_t hndlSem)
{
	if(hndlSem == NULL){
		ERR("SemWait: Invalid Semaphore handler\n");
		return -1;
	}
	return pthread_mutex_lock(hndlSem);
}

/*删除*/
int DestroySem(SemHandl_t hndlSem)
{
	if(hndlSem == NULL){
		ERR("DestroySem: Invalid Semaphore handler\n");
		return -1;
	}
	pthread_mutex_lock(hndlSem);
	pthread_mutex_unlock(hndlSem);
	if(pthread_mutex_destroy(hndlSem) !=0){
		ERR("Sem_kill faill!!\n");
	}
	free(hndlSem);
	return 0;
}

有了以上基础就可以再多线程中测试了，下面的代码是在上篇文章的基础上修改的

thread.c 源文件

#include 
#include 
#include 
#include 

#include "pthread_mutex.h"

#define __DEBUG
#ifdef __DEBUG
#define DBG(fmt,args...) fprintf(stdout,  fmt,  ##args)
#else
#define DBG(fmt,args...)
#endif
#define ERR(fmt,args...) fprintf(stderr,  fmt,  ##args)

static int isThreadQuit = 0;
SemHandl_t gHndlSem = NULL;

/*
某设备写操作，不同同时访问，所以所以需要线程锁保护
1、将函数DeviceWrite中加锁
2、在访问DeviceWrite的线程中加锁
以上两种方法跟据需要选择其一。
本例中在访问的线程中加锁
*/
void DeviceWrite(char *str)
{
	/*SemWait(gHndlSem);*/
	DBG("Device Write: %s\n",str);
	/*SemRelease(gHndlSem);*/
}
void SetXxThreadQuit()
{	
	/*quit*/
	isThreadQuit = 1;
}
void *XxManageThread(void *arg)
{
	char *cmd = (char*)arg;
	DBG("arg value=%s\n",cmd);
	while(isThreadQuit==0){
		SemWait(gHndlSem);
		DeviceWrite("thread 1");
		SemRelease(gHndlSem);
		sleep(1);
	}
	/*arg是将指针带进来，cmd则相反，或者设置 NULL*/
	pthread_exit(cmd);
	//pthread_exit(NULL);
}
void *XxManageThreadMutex(void *arg)
{
	char *cmd = (char*)arg;
	DBG("arg value=%s\n",cmd);
	while(isThreadQuit==0){
		SemWait(gHndlSem);
		DeviceWrite("thread 2");
		SemRelease(gHndlSem);
		sleep(1);
	}
	/*arg是将指针带进来，cmd则相反，或者设置 NULL*/
	pthread_exit(cmd);
	//pthread_exit(NULL);
}

int XxManageThreadInit()
{
	pthread_t tManageThread;
	pthread_t tManageThreadMutex;
	
	char *any="any value";
	char *retn;
	int ret;
	/*
	  第二个参数是设置线程属性，一般很少用到(设置优先级等)，第四个参数为传递到线程的指针，
	  可以为任何类型
	*/
	ret = pthread_create(&tManageThread,NULL,XxManageThread,"1 thread");
	if(ret == -1){
		/*成功返回0.失败返回-1*/
		ERR("Ctreate Thread ERROR\n");
		return -1;
	}

	ret = pthread_create(&tManageThreadMutex,NULL,XxManageThreadMutex,"2 thread");
	if(ret == -1){
		/*成功返回0.失败返回-1*/
		ERR("Ctreate Thread ERROR\n");
		return -1;
	}
	
	/*
	  设置线程退出时资源的清理方式，如果是detach，退出时会自动清理
	  如果是join，则要等待pthread_join调用时才会清理
	*/
	pthread_detach(tManageThread);
	pthread_detach(tManageThreadMutex);
	//pthread_join(tManageThread,retn);
	//DBG("retn value=%s\n",retn);
	return 0;
}

#define TEST_MAIN
#ifdef TEST_MAIN
int main()
{
	printf("hello liuyu\n");
	int count=3;
	/*创建线程锁*/
	gHndlSem = MakeSem();
	if(gHndlSem == NULL){
		return -1;
	}
	
	if(XxManageThreadInit()==-1){
		exit(1);
	}
	
	while(count--){
		DBG("[0] main running\n");
		sleep(2);
	}
	
	SetXxThreadQuit();
	/*等待线程结束*/
	sleep(1);
	/*删除线程锁*/
	DestroySem(gHndlSem);
	DBG("waitting thread exit...\n");
	return 0;
}
#endif

互斥锁保证使共享资源在同一时间内，只有能有一个进程或者线程对他进行操作。