Linux基礎編程 多線程中的互斥鎖 pthread_mutex_lock

pthread_mutex.h頭文件

1. #ifndef __SEM_UTIL_H__   
2. #define __SEM_UTIL_H__   
3.   
4. typedef void* SemHandl_t;  
5.   
6. SemHandl_t MakeSem(); ///< Initialize the semaphore.   
7. int SemRelease(SemHandl_t hndlSem); ///< Unlock the semaphore.   
8. int SemWait(SemHandl_t hndlSem); ///< Lock the semaphore.   
9. int DestroySem(SemHandl_t hndlSem); ///< Destory the semaphore.   
10.   
11.   
12. #endif  

#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源文件

1. /* 
2. 互斥鎖用來保證一段時間內只有一個線程在執行一段代碼。 
3. 必要性顯而易見：假設各個線程向同一個文件順序寫入數據， 
4. 最後得到的結果一定是災難性的。 
5. */  
6. #include <stdio.h>   
7. #include <stdlib.h>   
8. #include <unistd.h>   
9. #include <pthread.h>   
10.   
11. #include "pthread_mutex.h"   
12.   
13. #define __DEBUG   
14. #ifdef __DEBUG   
15. #define DBG(fmt,args...) fprintf(stdout,  fmt,  ##args)   
16. #else   
17. #define DBG(fmt,args...)   
18. #endif   
19. #define ERR(fmt,args...) fprintf(stderr,  fmt,  ##args)   
20.   
21. /*線程互斥鎖初始化*/  
22. SemHandl_t MakeSem()  
23. {  
24.     SemHandl_t hndlSem = malloc(sizeof(pthread_mutex_t));  
25.     if(hndlSem == NULL){  
26.         ERR("Not enough memory!!\n");  
27.         return NULL;  
28.     }  
29.     /* Initialize the mutex which protects the global data */  
30.     if(pthread_mutex_init(hndlSem, NULL) != 0){  
31.         ERR("Sem init faill!!\n");  
32.         free(hndlSem);  
33.         return NULL;  
34.     }  
35.     return hndlSem;  
36. }  
37.   
38. /*線程互斥鎖釋放*/  
39. int SemRelease(SemHandl_t hndlSem)  
40. {  
41.     if(hndlSem == NULL){  
42.         ERR("SemRelease: Invalid Semaphore handler\n");  
43.         return -1;  
44.     }  
45.     return pthread_mutex_unlock(hndlSem);  
46. }  
47.   
48. /*等待*/  
49. int SemWait(SemHandl_t hndlSem)  
50. {  
51.     if(hndlSem == NULL){  
52.         ERR("SemWait: Invalid Semaphore handler\n");  
53.         return -1;  
54.     }  
55.     return pthread_mutex_lock(hndlSem);  
56. }  
57.   
58. /*刪除*/  
59. int DestroySem(SemHandl_t hndlSem)  
60. {  
61.     if(hndlSem == NULL){  
62.         ERR("DestroySem: Invalid Semaphore handler\n");  
63.         return -1;  
64.     }  
65.     pthread_mutex_lock(hndlSem);  
66.     pthread_mutex_unlock(hndlSem);  
67.     if(pthread_mutex_destroy(hndlSem) !=0){  
68.         ERR("Sem_kill faill!!\n");  
69.     }  
70.     free(hndlSem);  
71.     return 0;  
72. }  

/*
互斥鎖用來保證一段時間內只有一個線程在執行一段代碼。
必要性顯而易見：假設各個線程向同一個文件順序寫入數據，
最後得到的結果一定是災難性的。
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>

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