linux多线程编程3--mutex-CSDN博客

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

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