【c语言】多线程互斥锁练习题

第一题：测试错误检查锁和递归锁是否会造成死锁状态。

答：都不会造成死锁状态。

错误检查锁：

用pthread_mutex_lock函数上锁时，会检查该锁是否是重复上锁，上锁失败返回错误码，上锁成功返回0，这个锁可以防止程序死锁。

代码：

#include<myheadIO.h>
#include<pthread.h>

pthread_mutex_t errchmutex1;
pthread_mutex_t errchmutex2;


void* fun1()
{
	while(1)
	{
		fflush(stdout);
		if(pthread_mutex_lock(&errchmutex2)==0)
		{
			printf("上锁成功:");
		}else
		{
			printf("上锁失败:");
		}
		printf("errc1\n");
		sleep(1);
	}
}

int main(int argc, const char *argv[])
{
	pthread_mutex_t attr;
	pthread_mutexattr_init(&attr);
	pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_ERRORCHECK);
	pthread_mutex_init(&errchmutex1,&attr);
	pthread_mutex_init(&errchmutex2,&attr);

	pthread_t id;
	pthread_create(&id,0,fun1,0);
	pthread_detach(id);

	while(1)
	{
		fflush(stdout);
		if(pthread_mutex_lock(&errchmutex1)==0)
		{
			printf("上锁成功:");
		}else
		{
			printf("上锁失败:");
		}
		printf("errc2\n");
		sleep(1);
	}



	return 0;
}

测试结果：

（编译时，因为线程的函数都是外部函数，gcc后面要加-lpthread）

 递归锁：

用pthread_mutex_lock函数上锁时，会检查该锁是否是重复上锁，上锁成功返回0，这种锁会在函数内部记录上锁次数，需要同样次数的解锁操作才能完全解锁这个锁，也可以防止程序死锁。

代码：

#include<myheadIO.h>
#include<pthread.h>

pthread_mutex_t recursive_mutex1;
pthread_mutex_t recursive_mutex2;


void* fun1()
{
	while(1)
	{
		if(pthread_mutex_lock(&recursive_mutex2)==0)
		{
			printf("上锁成功：");
		}else
		{
			printf("上锁失败：");
		}
		printf("errc1\n");
		sleep(1);
	}
}

int main(int argc, const char *argv[])
{
	pthread_mutex_t attr;
	pthread_mutexattr_init(&attr);
	pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE_NP);
	pthread_mutex_init(&recursive_mutex1,&attr);
	pthread_mutex_init(&recursive_mutex2,&attr);

	pthread_t id;
	pthread_create(&id,0,fun1,0);
	pthread_detach(id);

	while(1)
	{
		//pthread_mutex_lock(&recursive_mutex1);
		if(pthread_mutex_lock(&recursive_mutex1)==0)
		{
			printf("上锁成功：");
		}else
		{
			printf("上锁失败：");
		}

		printf("errc2\n");
		sleep(1);
	}



	return 0;
}

测试结果：

第二题：有两条隧道，一条快速隧道，一条普通隧道。有5列火车，3列复习号，2列绿皮扭扭车。要求复习号2条隧道都能走，绿皮车只能走普通隧道。模拟火车过隧道的场景。

答：我假设绿皮扭扭车过普通隧道需要10秒，复习号过普通隧道需要5秒，过快速隧道需要2秒。

代码：

#include<pthread.h>
#include<myheadIO.h>

int comencar=2;//代表2列绿皮扭扭车数量
int fuxincar=3;//代表3列复习号数量
pthread_mutex_t mutex1;   //互斥锁
pthread_mutex_t mutex2;   //互斥锁

//子线程函数
void * fun()
{
	while(1)
	{
		if(fuxincar<1){break;}
		if(pthread_mutex_trylock(&mutex1)==0)
		{
			printf("复习号进入快速通道\n");
			sleep(2);
			printf("2s:复习号通过入快速通道\n");
			fuxincar--;
			printf("复习号还剩%d辆没过隧道\n",fuxincar);
			pthread_mutex_unlock(&mutex1);
		}else
		{
			if(fuxincar<2){break;}
			printf("复习号进入快速通道\n");
			sleep(2);
			printf("2s:复习号通过入快速通道\n");
			fuxincar--;
			printf("复习号还剩%d辆没过隧道\n",fuxincar-1);
		}
	}
}
void *fun2()
{
	while(1)
	{
		if(fuxincar<1){break;}
		pthread_mutex_lock(&mutex2);
		if(pthread_mutex_trylock(&mutex1)==0)
		{
			printf("复习号通过入普通通道\n");
			sleep(5);
			printf("5s:复习号通过普通通道\n");
			fuxincar--;
			printf("复习号还剩%d辆没过隧道\n",fuxincar);
			pthread_mutex_unlock(&mutex1);
		}else
		{
			if(fuxincar<2){break;}
			printf("复习号通过入普通通道\n");
			sleep(5);
			printf("5s:复习号通过普通通道\n");
			fuxincar--;
			printf("复习号还剩%d辆没过隧道\n",fuxincar-1);
		}
		pthread_mutex_unlock(&mutex2);
	}
}

int main(int argc, const char *argv[])
{
	//错误检查互斥锁
	pthread_mutex_t attr;
	pthread_mutexattr_init(&attr);
	pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_ERRORCHECK);
	pthread_mutex_init(&mutex1,&attr);
	//快速锁
	pthread_mutex_init(&mutex2,0);
	
	//两个线程定义
	pthread_t id;
	pthread_t id2;
	pthread_create(&id,0,fun,0);
	pthread_create(&id2,0,fun2,0);

	while(1)
	{
		if(comencar<1){break;}
		pthread_mutex_lock(&mutex2);
		printf("绿皮扭扭车进入普通隧道\n");
		sleep(10);
		printf("10s:绿皮扭扭车通过入普通隧道\n");
		comencar--;
		pthread_mutex_unlock(&mutex2);
	}

	if(comencar==0&&fuxincar==0)
	{
		printf("火车都走完了！\n");
	}

	return 0;
}

测试结果：