11.线程：互斥锁

lidaxia_it

已于 2023-05-12 20:06:22 修改

阅读量85

点赞数

分类专栏： Linux学习笔记文章标签： c语言 linux

于 2023-04-22 19:43:09 首次发布

本文链接：https://blog.csdn.net/lidaxia_it/article/details/130308516

版权

Linux学习笔记专栏收录该内容

10 篇文章 2 订阅

订阅专栏

与互斥锁相关API

　　任何程序都可以看做互斥量。在运行前对互斥量进行加锁，在访问完成后释放互斥量上的锁。对互斥量进行加锁后，任何其他试图再次“对另一个互斥量加锁的线程”将会被阻塞在上锁的位置，直到当前线程释放该互斥锁。如果释放互斥锁时有多个线程阻塞，所有在该互斥锁上的阻塞线程都会变成可运行状态，第一个变为可运行状态的线程可以对互斥量加锁，其他线程将会看到互斥锁依然被锁住，只能回去等待它重新变为可用。等同于一个程序上锁后，其它所有上锁的程序阻塞在上锁的位置，等当前程序解锁后，所有上锁的程序竞争，依次循环。在这种方式下，每次只有一个线程可以向前运行。

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

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

　　1. 创建及销毁互斥锁

#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
int pthread_mutex_destroy(pthread_mutex_t *mutex);
// 返回：若成功返回0，否则返回错误编号
// pthread_mutex_t mutex 建议全局变量

　　要用默认的属性初始化互斥量，只需把attr设置为NULL。　　

　　2. 加锁及解锁

#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
// 返回：若成功返回0，否则返回错误编号

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

对线程加锁：

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

pthread_mutex_t mutex;

void *fun1(void * arg){
	pthread_mutex_lock(&mutex);
	static int a=10;
	printf("t1 : %d\n",*((int *)arg));
	printf("t1 ID : %ld\n",(unsigned long)pthread_self());
	pthread_mutex_unlock(&mutex);
	pthread_exit((void *)&a);
	

}
void *fun2(void * arg){
	pthread_mutex_lock(&mutex);
	static int a=20;
	printf("t2 : %d\n",*((int *)arg));
	printf("t2 ID : %ld\n",(unsigned long)pthread_self());
	pthread_mutex_unlock(&mutex);
	pthread_exit((void *)&a);
	
	

}
void *fun3(void * arg){
	pthread_mutex_lock(&mutex);
	static int a=30;
	printf("t3 : %d\n",*((int *)arg));
	printf("t3 ID : %ld\n",(unsigned long)pthread_self());
	pthread_mutex_unlock(&mutex);
	pthread_exit((void *)&a);
	

}
int main(){
	
	int a;
	int *pre;
	pthread_t t1;
	pthread_t t2;
	pthread_t t3;
	int date=520;
	
	pthread_mutex_init(&mutex,NULL);
//三个子线程同时运行，不知道先抢到锁，很大概率最先创建的最先运行
	a=pthread_create(&t2,NULL,fun2,(void *)&date);
	if(a==0)
		printf("pthread_create ture\n");
	a=pthread_create(&t1,NULL,fun1,(void *)&date);
	if(a==0)
		printf("pthread_create ture\n");	 
	a=pthread_create(&t3,NULL,fun3,(void *)&date);
	if(a==0)
		printf("pthread_create ture\n");
	
	pthread_join(t1,(void **)&pre);
	printf("t1 return %d \n",*pre);
	pthread_join(t2,(void **)&pre);
	pthread_join(t3,(void **)&pre);
	

	pthread_mutex_destroy(&mutex);
	return 0;
}

对共享内存上锁

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

pthread_mutex_t mutex;
int data=0;
//t1、t2都有可能先运行
void *fun1(void * arg){
	
	static int a=10;
	printf("t1 run : %d\n",*((int *)arg));
	pthread_mutex_lock(&mutex);
	while(1){
		printf("t1: %d\n",data++);
		sleep(1);
		if(data==3){
			printf("t1 quit=========================\n");
			pthread_mutex_unlock(&mutex);
			pthread_exit(NULL);
		}
		
	}
	pthread_exit((void *)&a);

}
void *fun2(void * arg){
	
	static int a=10;
	printf("t2 run : %d\n",*((int *)arg));
//即使t2先运行，加1后，解锁睡眠，此时t1获取锁，直到3
	while(1){
		pthread_mutex_lock(&mutex);
		printf("t2: %d\n",++data);	
		pthread_mutex_unlock(&mutex);
		sleep(1);
		if(data==5){
			printf("t2 quit=========================\n");
			pthread_mutex_unlock(&mutex);
			pthread_exit(NULL);
		}
	}
	pthread_exit(NULL);

}
int main(){
	
	int a;
	int *pre;
	pthread_t t1;
	pthread_t t2;
	int date=520;
	
	pthread_mutex_init(&mutex,NULL);

	a=pthread_create(&t1,NULL,fun1,(void *)&date);
	if(a==0)
		printf("t1 create ture\n");
	a=pthread_create(&t2,NULL,fun2,(void *)&date);
	if(a==0)
		printf("t2 create ture\n");
	pthread_join(t1,NULL);
	pthread_join(t2,NULL);

	pthread_mutex_destroy(&mutex);
	return 0;
}

什么是死锁

当存在2个线程a和b，有两个锁1和2。线程1拿到锁1后想要继续拿锁2，但此时线程2运行。线程2拿到锁2后，想要拿锁1。此时线程a和b，都会卡住无法往下运行，这种情况就是死锁。

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

pthread_mutex_t mutex;
pthread_mutex_t mutex2;

void *fun1(void * arg){
	pthread_mutex_lock(&mutex);
	sleep(1);
	pthread_mutex_lock(&mutex2);
	static int a=10;
	printf("t1 : %d\n",*((int *)arg));
	printf("t1 ID : %ld\n",(unsigned long)pthread_self());
	pthread_mutex_unlock(&mutex);
	pthread_exit((void *)&a);
	

}
void *fun2(void * arg){
	pthread_mutex_lock(&mutex2);
	sleep(1);
	pthread_mutex_lock(&mutex);
	static int a=20;
	printf("t2 : %d\n",*((int *)arg));
	printf("t2 ID : %ld\n",(unsigned long)pthread_self());
	pthread_mutex_unlock(&mutex);
	pthread_exit((void *)&a);
	
	

}
void *fun3(void * arg){
	pthread_mutex_lock(&mutex);
	static int a=30;
	printf("t3 : %d\n",*((int *)arg));
	printf("t3 ID : %ld\n",(unsigned long)pthread_self());
	pthread_mutex_unlock(&mutex);
	pthread_exit((void *)&a);
	

}
int main(){
	
	int a;
	int *pre;
	pthread_t t1;
	pthread_t t2;
	pthread_t t3;
	int date=520;
	
	pthread_mutex_init(&mutex,NULL);

	a=pthread_create(&t3,NULL,fun3,(void *)&date);
	if(a==0)
		printf("pthread_create t3 ture\n");
	a=pthread_create(&t1,NULL,fun1,(void *)&date);
	if(a==0)
		printf("pthread_create t2 ture\n");	 
	a=pthread_create(&t2,NULL,fun2,(void *)&date);
	if(a==0)
		printf("pthread_create t1 ture\n");
	
	pthread_join(t3,(void **)&pre);
	printf("t3: 666 %d\n",(int)*pre);
	pthread_join(t2,(void **)&pre);
	pthread_join(t1,(void **)&pre);

	

	pthread_mutex_destroy(&mutex);
	return 0;
}