十字路口信号灯

有两条道路双向两个车道，即每条路每个方向只有一个车道，两条道路十字交叉。假设车辆只能向前直行，而不允许转弯和后退。如果有4辆车几乎同时到达这个十字路口，如图（a）所示；相互交叉地停下来，如图（b），此时4辆车都将不能继续向前，这是一个典型的死锁问题。从操作系统原理的资源分配观点，如果4辆车都想驶过十字路口，那么对资源的要求如下：

• 向北行驶的车1需要象限a和b；
• 向西行驶的车2需要象限b和c；
• 向南行驶的车3需要象限c和d；
• 向东行驶的车4需要象限d和a。

双向同行

上课的时候写的，允许同时双向通行，三向通行的先摸了

代码如下：

#pragma comment(lib, "pthreadVC2.lib")
#include <pthread.h>  
#include <stdio.h>  
#include <Windows.h>
#include <stdlib.h>
#include <time.h>

#define MAX 65535

/*
	操作系统十字路口信号灯作业：
	目前仅支持南北方向或者东西方向同时通行
	采用3个信号灯判断，其中1个信号灯用于为东西方向或者南北方向的车辆抢占路口
	剩下2个信号灯表示某个方向有车辆到来
	利用随机数来模拟不同时刻从不同方向到达路口的车辆
	例：当东方向有车辆到来，此车辆是第一个到达路口的，占据了路口，每当东西方向有车辆过来就允许通行
	直到东西方向没有车辆到来，才允许南北方向的车辆通行

	输入：为产生车辆的总数，设置最大值为65535
	输出：产生的随机车辆通过路口的情况

*/
//5个互斥信号灯
pthread_mutex_t mutex_road; //道路信号灯
pthread_mutex_t mutex_we;  //西到东方向信号灯
pthread_mutex_t mutex_ns; //南北方向信号灯



//进程数组，用于保存所有车辆进程
pthread_t car[MAX];

//车辆数计数
int size = 0;

//初始化南北方向和东西方向到达路口的车辆数
int numOfWE = 0, numOfNS = 0;

//当前各个方向上的车辆ID
/*int current_north;
int current_south;
int current_east;
int current_west;*/


//车辆队列，用于描述从各个方向到达的车辆
struct queue
{
	pthread_t thread[MAX];
	int num[MAX];  //车辆序号
	int front; //头指针
	int rear; //尾指针
	int count; //队列里的车辆数

	queue() {
		front = rear = count = 0;
	}
	void push(int n) { //车辆入队
		count++;
		rear = (rear + 1) % MAX;
		num[rear] = n;
	}
	int pop() {//车辆出队
		count--;
		front = (front + 1) % MAX;
		return num[front];
	}
};

//4个方向的车辆队列
queue car_south;
queue car_east;
queue car_north;
queue car_west;

void* car_from_west(void* arg) {

	int current_west;
	time_t start, end;  //计时变量
	double lastTimes;

	if (car_west.count > 0)
		 current_west = car_west.pop();
	printf("第 %d  辆车从西方向到达路口\n", current_west);

	start = clock();  //开始计时

	Sleep(1000);

	pthread_mutex_lock(&mutex_we);
	numOfWE++;
	if(numOfWE == 1)  //东西方向到达路口的第一辆车先抢占道路
		pthread_mutex_lock(&mutex_road);
	pthread_mutex_unlock(&mutex_we);

	end = clock();
	lastTimes = (double)(end - start) / CLOCKS_PER_SEC;

	printf("第 %d  辆车从西方向到达路口等待了 %lfs 并从东方向离开路口\n", current_west,lastTimes);
	pthread_mutex_lock(&mutex_we);
	numOfWE--;
	if(numOfWE == 0) //如果东西方向上没有车了，解锁信号灯
		pthread_mutex_unlock(&mutex_road);
	pthread_mutex_unlock(&mutex_we);
	return NULL;
}

void* car_from_east(void* arg) {

	int current_east;
	time_t start, end;  //计时变量
	double lastTimes;

	if (car_east.count > 0)
		current_east = car_east.pop();
	printf("第 %d  辆车从东方向到达路口\n", current_east);

	start = clock();  //开始计时

	Sleep(1000);

	pthread_mutex_lock(&mutex_we);
	numOfWE++;
	if (numOfWE == 1)  //东西方向到达路口的第一辆车先抢占道路
		pthread_mutex_lock(&mutex_road);
	pthread_mutex_unlock(&mutex_we);

	end = clock();
	lastTimes = (double)(end - start) / CLOCKS_PER_SEC;

	printf("第 %d  辆车从东方向到达路口等待了 %lfs 并从西方向离开路口\n", current_east, lastTimes);
	pthread_mutex_lock(&mutex_we);
	numOfWE--;
	if (numOfWE == 0) //如果东西方向上没有车了，解锁信号灯
		pthread_mutex_unlock(&mutex_road);
	pthread_mutex_unlock(&mutex_we);
	return NULL;
}

void* car_from_south(void* arg) {

	int current_south;
	time_t start, end;  //计时变量
	double lastTimes;

	if (car_south.count > 0)
		current_south = car_south.pop();

	start = clock();  //开始计时

	Sleep(1000);

	printf("第 %d  辆车从南方向到达路口\n", current_south);

	pthread_mutex_lock(&mutex_ns);
	numOfNS++;
	if (numOfNS == 1)  //南北方向到达路口的第一辆车先抢占道路
		pthread_mutex_lock(&mutex_road);
	pthread_mutex_unlock(&mutex_ns);

	end = clock();
	lastTimes = (double)(end - start) / CLOCKS_PER_SEC;

	printf("第 %d  辆车从南方向到达路口等待了 %lfs 并从北方向离开路口\n", current_south,lastTimes);
	pthread_mutex_lock(&mutex_ns);
	numOfNS--;
	if (numOfNS == 0) //如果南北方向上没有车了，解锁信号灯
		pthread_mutex_unlock(&mutex_road);
	pthread_mutex_unlock(&mutex_ns);
	return NULL;
}

void* car_from_north(void* arg) {

	int current_north;
	time_t start, end;  //计时变量
	double lastTimes;

	if(car_north.count > 0)
		current_north = car_north.pop();

	printf("第 %d  辆车从北方向到达路口\n", current_north);

	start = clock();  //开始计时

	Sleep(1000);

	pthread_mutex_lock(&mutex_ns);
	numOfNS++;
	if (numOfNS == 1)  //南北方向到达路口的第一辆车先抢占道路
		pthread_mutex_lock(&mutex_road);
	pthread_mutex_unlock(&mutex_ns);

	end = clock();
	lastTimes = (double)(end - start) / CLOCKS_PER_SEC;

	printf("第 %d  辆车从北方向到达路口等待了 %lfs 并从南方向离开路口\n", current_north,lastTimes);

	pthread_mutex_lock(&mutex_ns);
	numOfNS--;
	if (numOfNS == 0) //如果南北方向上没有车了，解锁信号灯
		pthread_mutex_unlock(&mutex_road);
	pthread_mutex_unlock(&mutex_ns);
	return NULL;
}

int main(int argc, char** argv) {

	//初始化信号灯
	pthread_mutex_init(&mutex_road,NULL);
	pthread_mutex_init(&mutex_we, NULL);
	pthread_mutex_init(&mutex_ns, NULL);

	/*printf("\n以n表示从北方向到达路口的车辆，s表示南方，w表示西方，e表示东方");*/
	int len = 0;
	printf("请输入到达路口的车辆总数：");
	scanf_s("%d", &len);
	srand(time(NULL));
	printf("开始产生随机车辆队列\n");
	printf("--------------------------------------------------\n");
	int Car = 0;  //随机数用于标记产生的车辆是从哪个方向到达路口
	//创建线程
	for (int i = 0; i < len; i++) {
		Car = rand() % 4;
		switch (Car)
		{
		case 0: {  //0表示从西方向到达路口
			car_west.push(i + 1);
			car[size++] = car_west.thread[car_west.front];
			pthread_create(&car_west.thread[car_west.front],NULL, car_from_west, NULL);
			break;
		}
		case 1: {  //1表示从东方向到达路口
			car_east.push(i + 1);
			car[size++] = car_east.thread[car_east.front];
			pthread_create(&car_east.thread[car_east.rear],NULL, car_from_east, NULL);
			break;
		}
		case 2: {  //2表示从南方向到达路口
			car_south.push(i + 1);
			car[size++] = car_south.thread[car_south.rear];
			pthread_create(&car_south.thread[car_south.rear],NULL, car_from_south, NULL);
			break;
		}
		case 3: {  //3表示从北方向到达路口
			car_north.push(i + 1);
			car[size++] = car_north.thread[car_north.rear];
			pthread_create(&car_north.thread[car_north.rear],NULL, car_from_north, NULL);
			break;
		}
		default:
			break;
		}
	}

	//加入进程
	for (int i = 0; i < len; i++) {
		pthread_join(car[i], NULL);
	}

}