Linux线程同步之互斥量加锁解锁pthread_mutex_init、pthread_mutex_destroy、pthread_mutex_lock、 pthread_mutex_unlock

目录

1.  什么是互斥锁

2、什么是共享资源

3、与互斥锁相关的API

（1）创建互斥锁

（2）pthread_mutex_init()____初始化互斥锁 

（3）pthread_mutex_destroy()___销毁互斥锁

（4）pthread_mutex_lock()___加锁

（5）pthread_mutex_unlock()___解锁

        举例：如何创建一个互斥锁代码实现

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

（6）什么情况会造成死锁

---

1.  什么是互斥锁

        互斥量也称为互斥锁，对共享资源进行锁定，保证同一时刻只能有一个线程去操作。

注意: 互斥锁是多个线程一起去抢，抢到锁的线程先执行，没有抢到锁的线程需要等待，等互斥锁使用完释放后，其它等待的线程再去抢这个锁。

2、什么是共享资源

在加锁与解锁中间的代码，叫做共享资源。

3、与互斥锁相关的API

（1）创建互斥锁

pthread_mutex_t mutex;    //此创建的互斥锁为全局变量

（2）pthread_mutex_init()____初始化互斥锁 

#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);

pthread_mutex_t *restrict mutex：           锁的地址
const pthread_mutexattr_t *restrict attr：  锁的属性，默认写NULL

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

（3）pthread_mutex_destroy()___销毁互斥锁

#include <pthread.h>
int pthread_mutex_destroy(pthread_mutex_t *mutex);

pthread_mutex_t *mutex:      锁的地址，是一个指针

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

（4）pthread_mutex_lock()___加锁

#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);

pthread_mutex_t *mutex:      锁的地址，是一个指针
// 返回：若成功返回0，否则返回错误编号

（5）pthread_mutex_unlock()___解锁

#include <pthread.h>
int pthread_mutex_unlock(pthread_mutex_t *mutex);

pthread_mutex_t *mutex：     锁的地址，是一个指针
// 返回：若成功返回0，否则返回错误编号

        举例：如何创建一个互斥锁代码实现

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

int g_data = 0;
pthread_mutex_t mutex;                  //创建一个互斥锁

void *func1(void *arg){
	int i;
	pthread_mutex_lock(&mutex);         //加锁
	for(i=0;i<5;i++){

		printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
		printf("t1:param is %d\n",*((int *)arg));
		sleep(1);
	}
	pthread_mutex_unlock(&mutex);       //解锁
}

void *func2(void *arg){

        pthread_mutex_lock(&mutex);    //加锁

        printf("t2:%ld thread is create\n",(unsigned long)pthread_self());
        printf("t2:param is %d\n",*((int *)arg));

	pthread_mutex_unlock(&mutex);      //解锁   
}

int main(){
	
	int ret;
	int param = 100;
	
	pthread_t t1;
	pthread_t t2;
	pthread_mutex_init(&mutex,NULL);    //初始化互斥锁

	ret = pthread_create(&t1,NULL,func1,(void *)&param);
	if(ret == 0){
		printf("main:pthread_create success\n");
	}

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

	printf("mian:%ld\n",(unsigned long)pthread_self());
	pthread_join(t1,NULL);
	pthread_join(t2,NULL);

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

执行结果： 

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

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

int g_data = 0;
pthread_mutex_t mutex;
void *func1(void *arg){
	
	printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
	printf("t1:param is %d\n",*((int *)arg));
	pthread_mutex_lock(&mutex);

	while(1){
		printf("t1:%d\n",g_data++);
		sleep(1);
		if(g_data == 3){			
			pthread_mutex_unlock(&mutex);
			printf("t1 quit =============================\n");
			exit(0);
		}
	}	
}

void *func2(void *arg){

        
        printf("t2:%ld thread is create\n",(unsigned long)pthread_self());
        printf("t2:param is %d\n",*((int *)arg));
	while(1){
                printf("t2:%d\n",g_data);
		pthread_mutex_lock(&mutex);
		g_data++;
		pthread_mutex_unlock(&mutex);
                sleep(1);
        }      
}

int main(){
	
	int ret;
	int param = 100;
	pthread_t t1;
	pthread_t t2;
	pthread_mutex_init(&mutex,NULL);
	

	ret = pthread_create(&t1,NULL,func1,(void *)&param);
	if(ret == 0){
		printf("main:pthread_create success\n");
	}

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

	printf("mian:%ld\n",(unsigned long)pthread_self());
	while(1){

                printf("main:%d\n",g_data);
                sleep(1);
        }

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

	pthread_mutex_destroy(&mutex);
	return 0;

}

执行结果：

（6）什么情况会造成死锁

首先要有两把锁A和B，当线程1先获得A锁后，想要再去获得B锁，这时线程2手里已经获得B锁后，想要再去获得A锁，这样线程1和线程2都想要拿到对方手里的那把锁，而且谁也不让着谁，谁都不肯去解锁。

死锁代码示例

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

int g_data = 0;
pthread_mutex_t mutex;
pthread_mutex_t mutex2;


void *func1(void *arg){
	int i;
	pthread_mutex_lock(&mutex);
	sleep(1);
	pthread_mutex_lock(&mutex2);
	for(i=0;i<5;i++){

		printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
		printf("t1:param is %d\n",*((int *)arg));
		sleep(1);
	}
	pthread_mutex_unlock(&mutex);
}

void *func2(void *arg){

    pthread_mutex_lock(&mutex2);
	sleep(1);
    pthread_mutex_lock(&mutex);

        printf("t2:%ld thread is create\n",(unsigned long)pthread_self());
        printf("t2:param is %d\n",*((int *)arg));

	pthread_mutex_unlock(&mutex);       
}

int main(){
	
	int ret;
	int param = 100;
	
	pthread_t t1;
	pthread_t t2;
	pthread_mutex_init(&mutex,NULL);
	pthread_mutex_init(&mutex2,NULL);

	ret = pthread_create(&t1,NULL,func1,(void *)&param);
	if(ret == 0){
		printf("main:pthread_create success\n");
	}

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

	printf("mian:%ld\n",(unsigned long)pthread_self());
	pthread_join(t1,NULL);
	pthread_join(t2,NULL);

	pthread_mutex_destroy(&mutex);
	pthread_mutex_destroy(&mutex2);
	return 0;
}

执行结果：