Linux编程练习 --多线程3--mutex

互斥指互相排斥的锁，是一种信号量，常用来防止两个进程或线程在同一时刻访问相同的共享资源

        

1.数据类型：

 在Linux下, 线程的互斥量数据类型是pthread_mutex_t，我们定义一个互斥数据可以这样：

              pthread_mutex_t mutex;

 

2.函数说明：
头文件：     pthread.h

（1）.互斥锁初始化：

 

函数原型： int pthread_mutex_init (pthread_mutex_t* mutex,

                                 const pthread_mutexattr_t*   mutexattr);
函数传入值:  mutex:互斥锁。

                mutexattr:PTHREAD_MUTEX_INITIALIZER:创建快速互斥锁。

                PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP:创建递归互斥锁。

                   PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP:创建检错互斥锁。

函数返回值： 成功：0

                   出错：-1 
（2）.互斥操作函数

int pthread_mutex_lock(pthread_mutex_t* mutex);//上锁

int pthread_mutex_trylock (pthread_mutex_t* mutex);//只有在互斥被锁住的情况下才阻塞

int pthread_mutex_unlock (pthread_mutex_t* mutex);//解锁

int pthread_mutex_destroy (pthread_mutex_t* mutex);//清除互斥锁

函数传入值：            mutex:互斥锁。

函数返回值：           成功：0

                              出错：-1

3.使用形式：

struct mutex mutex;

mutex_init(&mutex); /*定义*/

...
mutex_lock(&mutex); /*获取互斥锁*/

... /*临界资源*/

mutex_unlock(&mutex); /*释放互斥锁*/

 

 

最后进行一个练习：我们创建两个线程，分别访问全局变量gnum，并且修改它，打印出来

[cpp]  view plain copy

1. /*mutex.c*/  
2. #include <stdlib.h>    
3. #include <stdio.h>    
4. #include <pthread.h>    
5. #include <errno.h>     
6. /*全局变量*/  
7. int gnum = 0;  
8. /*互斥量 */  
9. pthread_mutex_t mutex;  
10. /*声明线程运行服务程序*/  
11. static void pthread_func_1 (void);     
12. static void pthread_func_2 (void);     
13.     
14. int main (void)     
15. {     
16.  /*线程的标识符*/  
17.   pthread_t pt_1 = 0;     
18.   pthread_t pt_2 = 0;     
19.   int ret = 0;     
20.   /*互斥初始化*/  
21.   pthread_mutex_init (&mutex, NULL);   
22.   /*分别创建线程1、2*/  
23.   ret = pthread_create (&pt_1,          //线程标识符指针  
24.                          NULL,          //默认属性  
25.                         (void *)pthread_func_1,//运行函数  
26.                         NULL);          //无参数  
27.   if (ret != 0)     
28.   {     
29.      perror ("pthread_1_create");     
30.   }     
31.     
32.   ret = pthread_create (&pt_2,          //线程标识符指针  
33.                         NULL,           //默认属性    
34.                         (void *)pthread_func_2, //运行函数  
35.                         NULL);          //无参数  
36.   if (ret != 0)     
37.   {     
38.      perror ("pthread_2_create");     
39.   }     
40.   /*等待线程1、2的结束*/  
41.   pthread_join (pt_1, NULL);     
42.   pthread_join (pt_2, NULL);     
43.     
44.   printf ("main programme exit!/n");    
45.   return 0;     
46. }     
47. /*线程1的服务程序*/  
48. static void pthread_func_1 (void)     
49. {     
50.   int i = 0;     
51.        
52.   for (;;)     
53.   {     
54.     printf ("This is pthread1!/n");      
55.     pthread_mutex_lock(&mutex); /*获取互斥锁*/  
56.     /*注意，这里以防线程的抢占，以造成一个线程在另一个线程sleep时多次访问互斥资源，所以sleep要在得到互斥锁后调用*/  
57.     sleep (1);    
58.     /*临界资源*/  
59.     gnum++;  
60.     printf ("Thread1 add one to num:%d/n",gnum);  
61.     pthread_mutex_unlock(&mutex); /*释放互斥锁*/  
62.   
63.        
64.   }     
65. }     
66. /*线程2的服务程序*/   
67. static void pthread_func_2 (void)     
68. {     
69.   int i = 0;     
70.     
71.   for (;;)     
72.   {     
73.     printf ("This is pthread2!/n");   
74.     pthread_mutex_lock(&mutex); /*获取互斥锁*/  
75.     /*注意，这里以防线程的抢占，以造成一个线程在另一个线程sleep时多次访问互斥资源，所以sleep要在得到互斥锁后调用*/  
76.     sleep (1);  
77.     /*临界资源*/  
78.     gnum++;  
79.     printf ("Thread2 add one to num:%d/n",gnum);  
80.     pthread_mutex_unlock(&mutex); /*释放互斥锁*/  
81.     
82.   }     
83.     
84.   pthread_exit (0);     
85. }    

然后编译，运行，看到是线程1，2分别和平地访问共享资源