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，并且修改它，打印出来

 

/*mutex.c*/
#include <stdlib.h> 
#include <stdio.h> 
#include <pthread.h> 
#include <errno.h>  

/*全局变量*/
int gnum = 0;
/*互斥量 */
pthread_mutex_t mutex;

/*声明线程运行服务程序*/
static void pthread_func_1 (void);  
static void pthread_func_2 (void);  
 
int main (void)  
{  
 /*线程的标识符*/
  pthread_t pt_1 = 0;  
  pthread_t pt_2 = 0;  
  int ret = 0;  

  /*互斥初始化*/
  pthread_mutex_init (&mutex, NULL);
  /*分别创建线程1、2*/
  ret = pthread_create (&pt_1,   //线程标识符指针
       NULL,   //默认属性
      (void *)pthread_func_1,//运行函数
      NULL);     //无参数
  if (ret != 0)  
  {  
     perror ("pthread_1_create");  
  }  
 
  ret = pthread_create (&pt_2,    //线程标识符指针
      NULL,   //默认属性 
      (void *)pthread_func_2, //运行函数
      NULL);     //无参数
  if (ret != 0)  
  {  
     perror ("pthread_2_create");  
  }  
  /*等待线程1、2的结束*/
  pthread_join (pt_1, NULL);  
  pthread_join (pt_2, NULL);  
 
  printf ("main programme exit!/n"); 
  return 0;  
}  

/*线程1的服务程序*/
static void pthread_func_1 (void)  
{  
  int i = 0;  
    
  for (;;)  
  {  
    printf ("This is pthread1!/n");   
    pthread_mutex_lock(&mutex); /*获取互斥锁*/
 /*注意，这里以防线程的抢占，以造成一个线程在另一个线程sleep时多次访问互斥资源，所以sleep要在得到互斥锁后调用*/
    sleep (1); 
    /*临界资源*/
    gnum++;
    printf ("Thread1 add one to num:%d/n",gnum);
    pthread_mutex_unlock(&mutex); /*释放互斥锁*/

    
  }  
}  
/*线程2的服务程序*/
static void pthread_func_2 (void)  
{  
  int i = 0;  
 
  for (;;)  
  {  
    printf ("This is pthread2!/n");
    pthread_mutex_lock(&mutex); /*获取互斥锁*/
 /*注意，这里以防线程的抢占，以造成一个线程在另一个线程sleep时多次访问互斥资源，所以sleep要在得到互斥锁后调用*/
    sleep (1);
    /*临界资源*/
    gnum++;
    printf ("Thread2 add one to num:%d/n",gnum);
    pthread_mutex_unlock(&mutex); /*释放互斥锁*/
 
  }  
 
  pthread_exit (0);  
} 

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

 

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/benny_cen/archive/2009/03/08/3969219.aspx