2024.5.11 作业 xyt

1：有一个隧道，全长5公里，有2列火车，全长200米，
                火车A时速 100公里每小时
                火车B时速 50公里每小时
                现在要求模拟火车反复通过隧道的场景(不可能2列火车都在隧道内运行)

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>
#include <semaphore.h>
#include <wait.h>
#include <signal.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <semaphore.h>
#include <sys/msg.h>
#include <sys/shm.h>
#include <sys/un.h>
void *train_A(void *arg);
void *train_B(void *arg);
int tunnel_long=5;//定义全局变量隧道长度5000m
int train_long=200/1000;//定义全局变量火车长度200m
pthread_mutex_t mutex;//互斥锁
pthread_cond_t cond;//条件变量
int main(int argc, const char *argv[])
{
	pthread_cond_init(&cond,0);
    pthread_mutex_init(&mutex,0);
    pthread_t thread_one;
    pthread_t thread_two;
    if(pthread_create(&thread_one,0,train_A,0)!=0){
		perror("线程创建失败");
		return -1;
    }
    if(pthread_create(&thread_two,0,train_B,0)!=0){
        perror("线程创建失败");
        return -1;
    }
    if(pthread_detach(thread_one)!=0){
        perror("线程分离失败");
        return -1;
    }
    if(pthread_detach(thread_two)!=0){
		perror("线程分离失败");
		return -1;
    }
    while(1){
		pthread_cond_signal(&cond);
    }
    return 0;
}
void * train_A(void *arg){
    while(1){
        pthread_mutex_lock(&mutex);
        pthread_cond_wait(&cond,&mutex);
        float train_speed=100;//火车A的s速度
        int sumlong=train_long+tunnel_long;//火车A需要走过的长度
        unsigned int train_time=sumlong/train_speed;
        printf("火车A正在通过中____AA\n");
        sleep(1);
        printf("火车A已经通过\n");
        pthread_mutex_unlock(&mutex);
    }
}
void * train_B(void *arg){
    while(1){
        pthread_mutex_lock(&mutex);
        pthread_cond_wait(&cond,&mutex);
        float train_speed=50;//火车B的s速度
        int sumlong=train_long+tunnel_long;//火车B需要走过的长度
        unsigned int train_time=sumlong/train_speed;
        printf("火车B正在通过中____BBBB\n");
        sleep(1);
        printf("火车B已经通过\n");
        pthread_mutex_unlock(&mutex);
    }
}

2：有一个隧道，全长5公里，有3列火车，全长200米，
                火车A时速 100公里每小时
                火车B时速 50公里每小时
                火车c时速 25公里每小时
                现在要求 火车A先通过隧道，火车B再通过隧道，最后火车C通过隧道

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>
#include <semaphore.h>
#include <wait.h>
#include <signal.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <semaphore.h>
#include <sys/msg.h>
#include <sys/shm.h>
#include <sys/un.h>

pthread_mutex_t mutex; // 互斥锁
pthread_cond_t cond_a; // 火车A的条件变量
pthread_cond_t cond_b; // 火车B的条件变量
pthread_cond_t cond_c; // 火车C的条件变量
int turn = 0; // 共享状态变量，表示轮到哪一辆火车
int tunnel_long=5000;//定义全局变量隧道长度5000m
int train_long=200;//定义全局变量火车长度200m
void *train_A(void *arg);
void *train_B(void *arg);
void *train_C(void *arg);
int main(int argc, const char *argv[]) {
	pthread_mutex_init(&mutex, NULL);
	pthread_cond_init(&cond_a, NULL);
	pthread_cond_init(&cond_b, NULL);
	pthread_cond_init(&cond_c, NULL);
	pthread_t thread_a, thread_b, thread_c;
	if(pthread_create(&thread_a, 0, train_A, 0)!=0){
		perror("线程创建失败");
		return -1;
	}
	if(pthread_create(&thread_b, 0, train_B, 0)!=0){
		perror("线程创建失败");
		return -1;
	}
	if(pthread_create(&thread_c, 0, train_C, 0)!=0){
		perror("线程创建失败");
		return -1;
	}
	pthread_join(thread_a, NULL);
	pthread_join(thread_b, NULL);
	pthread_join(thread_c, NULL);
	pthread_mutex_destroy(&mutex);
	pthread_cond_destroy(&cond_a);
	pthread_cond_destroy(&cond_b);
	pthread_cond_destroy(&cond_c);
	return 0;
}

void *train_A(void *arg) {
	while (1) {
		pthread_mutex_lock(&mutex);
		while (turn != 0) {
			pthread_cond_wait(&cond_a, &mutex); // 等待轮到自己
		}
		//火车A通过隧道
		float train_speed=10000*1000/3600.0;//火车A的s速度
		int sumlong=train_long+tunnel_long;//火车A需要走过的长度
		float travel_time = sumlong / train_speed;
		printf("火车A正在通过隧道____A\n");
		usleep((int)(travel_time * 1000000));
		printf("火车A已经通过隧道\n");

		// 轮到火车B，并发出信号
		turn = 1;
		pthread_cond_signal(&cond_b);
		pthread_mutex_unlock(&mutex);
	}
}

void *train_B(void *arg) {
	while (1) {
		pthread_mutex_lock(&mutex);
		while (turn != 1) {
			pthread_cond_wait(&cond_b, &mutex); // 等待轮到自己
		}
		// 火车B通过隧道
		float train_speed=10000*1000/3600.0;//火车B的s速度
		int sumlong=train_long+tunnel_long;//火车B需要走过的长度
		float travel_time = sumlong / train_speed;
		printf("火车B正在通过隧道____BB\n");
		usleep((int)(travel_time * 1000000));
		printf("火车B已经通过隧道\n");

		// 轮到火车C，并发出信号
		turn = 2;
		pthread_cond_signal(&cond_c);
		pthread_mutex_unlock(&mutex);
	}
}

void *train_C(void *arg) {
	while (1) {
		pthread_mutex_lock(&mutex);
		while (turn != 2) {
			pthread_cond_wait(&cond_c, &mutex); // 等待轮到自己
		}

		// 火车C通过隧道
		float train_speed=10000*1000/3600.0;//火车C的s速度
		int sumlong=train_long+tunnel_long;//火车C需要走过的长度
		float travel_time = sumlong / train_speed;
		printf("火车C正在通过隧道____CCC\n");
		usleep((int)(travel_time * 1000000));
		printf("火车C已经通过隧道\n");

		// 轮回到火车A，并发出信号
		turn = 0;
		pthread_cond_signal(&cond_a);
		pthread_mutex_unlock(&mutex);
	}
}