pthread_mutex_t的使用

转自：http://blog.163.com/coffee_666666/blog/static/184691114201182125470/

           http://blog.csdn.net/wypblog/article/details/7264315

 

1. 互斥锁创建
        有两种方法创建互斥锁，静态方式和动态方式。POSIX定义了一个宏PTHREAD_MUTEX_INITIALIZER来静态初始化互斥锁，方法如下：

              pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;

              在LinuxThreads实现中，pthread_mutex_t是一个结构，而PTHREAD_MUTEX_INITIALIZER则是一个结构常量。

　　动态方式是采用pthread_mutex_init()函数来初始化互斥锁，API定义如下：

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr)

其中mutexattr用于指定互斥锁属性（见下），如果为NULL则使用缺省属性。

　　pthread_mutex_destroy ()用于注销一个互斥锁，API定义如下：

int pthread_mutex_destroy(pthread_mutex_t *mutex)

销毁一个互斥锁即意味着释放它所占用的资源，且要求锁当前处于开放状态。由于在Linux中，互斥锁并不占用任何资源，因此LinuxThreads中的 pthread_mutex_destroy()除了检查锁状态以外（锁定状态则返回EBUSY）没有其他动作。

　　2． 互斥锁属性

　　互斥锁的属性在创建锁的时候指定，在LinuxThreads实现中仅有一个锁类型属性，不同的锁类型在试图对一个已经被锁定的互斥锁加锁时表现不同。当前（glibc2.2.3,linuxthreads0.9）有四个值可供选择：

　　* PTHREAD_MUTEX_TIMED_NP，这是缺省值，也就是普通锁。当一个线程加锁以后，其余请求锁的线程将形成一个等待队列，并在解锁后按优先级获得锁。这种锁策略保证了资源分配的公平性。

　　* PTHREAD_MUTEX_RECURSIVE_NP，嵌套锁，允许同一个线程对同一个锁成功获得多次，并通过多次unlock解锁。如果是不同线程请求，则在加锁线程解锁时重新竞争。

　　* PTHREAD_MUTEX_ERRORCHECK_NP，检错锁，如果同一个线程请求同一个锁，则返回EDEADLK，否则与PTHREAD_MUTEX_TIMED_NP类型动作相同。这样就保证当不允许多次加锁时不会出现最简单情况下的死锁。

　　* PTHREAD_MUTEX_ADAPTIVE_NP，适应锁，动作最简单的锁类型，仅等待解锁后重新竞争。

　　3． 锁操作

　　锁操作主要包括加锁 pthread_mutex_lock()、解锁pthread_mutex_unlock()和测试加锁 pthread_mutex_trylock()三个，不论哪种类型的锁，都不可能被两个不同的线程同时得到，而必须等待解锁。对于普通锁和适应锁类型，解锁者可以是同进程内任何线程；而检错锁则必须由加锁者解锁才有效，否则返回EPERM；对于嵌套锁，文档和实现要求必须由加锁者解锁，但实验结果表明并没有这种限制，这个不同目前还没有得到解释。在同一进程中的线程，如果加锁后没有解锁，则任何其他线程都无法再获得锁。

　　int pthread_mutex_lock(pthread_mutex_t *mutex)

　　int pthread_mutex_unlock(pthread_mutex_t *mutex)

　　int pthread_mutex_trylock(pthread_mutex_t *mutex)

　　pthread_mutex_trylock()语义与pthread_mutex_lock()类似，不同的是在锁已经被占据时返回EBUSY而不是挂起等待。

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------

linux下为了多线程同步，通常用到锁的概念。
posix下抽象了一个锁类型的结构：ptread_mutex_t。通过对该结构的操作，来判断资源是否可以访问。顾名思义，加锁(lock)后，别人就无法打开，只有当锁没有关闭(unlock)的时候才能访问资源。
它主要用如下5个函数进行操作。
1：pthread_mutex_init(pthread_mutex_t * mutex,const pthread_mutexattr_t *attr);
初始化锁变量mutex。attr为锁属性，NULL值为默认属性。
2：pthread_mutex_lock(pthread_mutex_t *mutex);加锁
3：pthread_mutex_tylock(pthread_mutex_t *mutex);加锁，但是与2不一样的是当锁已经在使用的时候，返回为EBUSY，而不是挂起等待。
4：pthread_mutex_unlock(pthread_mutex_t *mutex);释放锁
5：pthread_mutex_destroy(pthread_mutex_t *mutex);使用完后释放
下面经典例子为创建两个线程对sum从1加到100。前面第一个线程从1－49，后面从50－100。主线程读取最后的加值。为了防止资源竞争，用了pthread_mutex_t 锁操作。

 

[cpp] view plaincopyprint?

1. #include<stdlib.h> 
2. #include<stdio.h> 
3. #include<unistd.h> 
4. #include<pthread.h> 
5. typedef struct ct_sum 
6. {   int sum; 
7.     pthread_mutex_t lock; 
8. }ct_sum; 
9. void * add1(void * cnt) 
10. {      
11.     
12.     pthread_mutex_lock(&(((ct_sum*)cnt)->lock)); 
13.     int i; 
14.         for( i=0;i<50;i++){ 
15.             (*(ct_sum*)cnt).sum+=i;} 
16.     pthread_mutex_unlock(&(((ct_sum*)cnt)->lock)); 
17.     pthread_exit(NULL); 
18.     return 0; 
19. } 
20. void * add2(void *cnt) 
21. {      
22.     int i; 
23.     cnt= (ct_sum*)cnt; 
24.     pthread_mutex_lock(&(((ct_sum*)cnt)->lock)); 
25.     for( i=50;i<101;i++) 
26.     {    (*(ct_sum*)cnt).sum+=i;        
27.     } 
28.     pthread_mutex_unlock(&(((ct_sum*)cnt)->lock)); 
29.     pthread_exit(NULL); 
30.     return 0; 
31. } 
32. int main(void) 
33. {   int i; 
34.     pthread_t ptid1,ptid2; 
35.     int sum=0; 
36.     ct_sum cnt; 
37.     pthread_mutex_init(&(cnt.lock),NULL); 
38.     cnt.sum=0; 
39.     pthread_create(&ptid1,NULL,add1,&cnt); 
40.     pthread_create(&ptid2,NULL,add2,&cnt); 
41.  
42.     pthread_mutex_lock(&(cnt.lock)); 
43.     printf("sum %d\n",cnt.sum); 
44.     pthread_mutex_unlock(&(cnt.lock)); 
45.     pthread_join(ptid1,NULL); 
46.     pthread_join(ptid2,NULL); 
47.     pthread_mutex_destroy(&(cnt.lock)); 
48.     return 0; 
49. }  
50.   

#include<stdlib.h>#include<stdio.h>#include<unistd.h>#include<pthread.h>typedef struct ct_sum{int sum;pthread_mutex_t lock;}ct_sum;void * add1(void * cnt){           pthread_mutex_lock(&(((ct_sum*)cnt)->lock));   int i;       for( i=0;i<50;i++){       (*(ct_sum*)cnt).sum+=i;}   pthread_mutex_unlock(&(((ct_sum*)cnt)->lock));  pthread_exit(NULL);  return 0;}void * add2(void *cnt){        int i;   cnt= (ct_sum*)cnt;   pthread_mutex_lock(&(((ct_sum*)cnt)->lock));   for( i=50;i<101;i++)   {    (*(ct_sum*)cnt).sum+=i;          }  pthread_mutex_unlock(&(((ct_sum*)cnt)->lock));   pthread_exit(NULL);   return 0;}int main(void){ int i;pthread_t ptid1,ptid2;int sum=0;ct_sum cnt;pthread_mutex_init(&(cnt.lock),NULL);cnt.sum=0;pthread_create(&ptid1,NULL,add1,&cnt);pthread_create(&ptid2,NULL,add2,&cnt);pthread_mutex_lock(&(cnt.lock));printf("sum %d\n",cnt.sum);pthread_mutex_unlock(&(cnt.lock));pthread_join(ptid1,NULL);pthread_join(ptid2,NULL);pthread_mutex_destroy(&(cnt.lock));return 0;}