Linux线程——互斥锁

概念

互斥量（mutex）从本质上来说是一把锁，在访问共享资源前对互斥量进行加锁，在访问完成后释放互斥量上的锁。对互斥量进行加锁后，任何其他试图再次对互斥量加锁的线程将会被阻塞直到当前线程释放该互斥锁。

如果释放互斥锁时有多个线程阻塞，所有在该互斥锁上的阻塞线程都会变成可运行状态，第一个变为可运行状态的线程可以对互斥量加锁，其他线程将会看到互斥锁依然被锁住，只能回去等待它重新变为可用。在这种方式下，每次只有一个线程可以向前运行。

在设计时需要规定所有的线程必须遵守相同的数据访问规则。只有这样，互斥机制才能正常工作。操作系统并不会做数据访问的串行化。如果允许其中的某个线程在没有得到锁的情况下也可以访问共享资源，那么即使其它的线程在使用共享资源前都获取了锁，也还是会出现数据不一致的问题。

互斥变量用pthread_mutex_t数据类型表示。在使用互斥变量前必须对它进行初始化，可以把它置为常量PTHREAD_MUTEX_INITIALIZER（只对静态分配的互斥量），也可以通过调用pthread_mutex_init函数进行初始化。如果动态地分配互斥量（例如通过调用malloc函数），那么在释放内存前需要调用pthread_mutex_destroy。

常用API

包含的头文件

#include <pthread.h>

创建互斥锁

函数原型

int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);

参数解读

*mutex	锁的地址，需定义一个pthread_mutex_t类型的全局变量。
attr	互斥量的属性，一般设为NULL，要用默认的属性初始化互斥量，只需把attr设置为NULL。

返回值

若成功返回0，否则返回错误编号。

销毁互斥锁

函数原型

int pthread_mutex_destroy(pthread_mutex_t mutex);

参数解读

*mutex：锁的地址，需定义一个pthread_mutex_t类型的全局变量。

返回值

若成功返回0，否则返回错误编号。

加锁互斥锁

函数原型

int pthread_mutex_lock(pthread_mutex_t mutex);

参数解读

*mutex：锁的地址，需定义一个pthread_mutex_t类型的全局变量。

返回值

若成功返回0，否则返回错误编号。

如果线程不希望被阻塞，它可以使用pthread_mutex_trylock尝试对互斥量进行加锁。如果调用pthread_mutex_trylock时互斥量处于未锁住状态，那么pthread_mutex_trylock将锁住互斥量，不会出现阻塞并返回0，否则pthread_mutex_trylock就会失败，不能锁住互斥量，而返回EBUSY。

解锁互斥锁

函数原型

int pthread_mutex_unlock(pthread_mutex_t *mutex);

参数解读

*mutex：锁的地址，需定义一个pthread_mutex_t类型的全局变量。

返回值

若成功返回0，否则返回错误编号。

代码示例

互斥锁的创建及加锁解锁

#include <stdio.h>
#include <pthread.h>

int data = 0;

pthread_mutex_t mutex;//定义一个互斥锁

void *func1(void *arg)
{
	int i;
	pthread_mutex_lock(&mutex);//上锁 执行到该锁时会进行其中代码 直到解锁后才会进行其他代码
	for(i=0;i<5;i++)
	{
        	printf("t1:this thread t1:%ld \n",(unsigned long)pthread_self());
        	printf("t1:num=%d\n",*((int *)arg));
	}
    pthread_mutex_unlock(&mutex);//解锁

}

void *func2(void *arg)
{
        pthread_mutex_lock(&mutex);
        printf("t2:this thread t2:%ld \n",(unsigned long)pthread_self());
        printf("t2:num=%d\n",*((int *)arg));
        pthread_mutex_unlock(&mutex);
}

int main()
{
        int ret;
        int num =999;
        pthread_t t1;
	    pthread_t t2;
	
	    pthread_mutex_init(&mutex,NULL);//初始化互斥锁
	
        ret = pthread_create(&t1,NULL,func1,(void *)&num);
        if(ret == 0)
	    {
                printf("main:create thread success\n");
        }

	    ret = pthread_create(&t2,NULL,func2,(void *)&num);
        if(ret == 0)
        {
                printf("main:create thread success\n");
        }

        printf("main:%ld\n",(unsigned long)pthread_self());	

	    pthread_join(t1,NULL);
	    pthread_join(t2,NULL);	

	    pthread_mutex_destroy(&mutex);//销毁互斥锁
        return 0;
}

?

由编译结果可知：t1会被main函数打断，但是不会被t2,t3打断,t1运行后t2,t3才能运行。

互斥锁限制共享资源的访问

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

int data = 0;

pthread_mutex_t mutex;

void *func1(void *arg)
{
    printf("t1:this thread t1:%ld \n",(unsigned long)pthread_self());
    printf("t1:num=%d\n",*((int *)arg));
	pthread_mutex_lock(&mutex); //上锁后执行下面语句
	while(1)
	{
		printf("ti:%d\n",data++);
		sleep(1);
		if(data==3)
		{
			pthread_mutex_unlock(&mutex);//解锁
			printf("over!!!!!!!!!!!!!!!!!!\n");//执行后结束func1线程
	//		pthread_exit(NULL);
			exit(0);//执行后结束整个进程
		}
	}
}

void *func2(void *arg)
{
    printf("t2:this thread t2:%ld \n",(unsigned long)pthread_self());
    printf("t2:num=%d\n",*((int *)arg));
	while(1)
	{
		printf("t2:%d\n",data);
		pthread_mutex_lock(&mutex);//func2进入检测锁的循环 判断func1是否解锁
		data++;
        pthread_mutex_unlock(&mutex);
		sleep(1);
	}
}

int main()
{
        int ret;
        int num =999;
        pthread_t t1;
	    pthread_t t2;
	
	    pthread_mutex_init(&mutex,NULL);
	
        ret = pthread_create(&t1,NULL,func1,(void *)&num);
        if(ret == 0)
	    {
            printf("main:create thread success\n");
        }

	    ret = pthread_create(&t2,NULL,func2,(void *)&num);
        if(ret == 0)
        {
            printf("main:create thread success\n");
        }

        printf("main:%ld\n",(unsigned long)pthread_self());	

	    while(1)
	    {
		    printf("main:%d\n",data);
		    sleep(1);
	    }
	
	    pthread_join(t1,NULL);
	    pthread_join(t2,NULL);	

	    pthread_mutex_destroy(&mutex);
        return 0;
}

由编译结果可知，func1线程结束后整个进程结束。