IO进程线程day5

思维导图

1> 将互斥机制代码重新实现一遍

#include<myhead.h>

//全局数组，临界资源
char buf[128];
//1、创建一个互斥锁
pthread_mutex_t mutex;

//定义分支线程
void *task(void *arg)
{
	while(1)
	{
		//3、获取锁资源
		pthread_mutex_lock(&mutex);

		printf("分支线程  buf = %s\n",buf);
		strcpy(buf,"I love China\n");

		//4、解放锁资源
		pthread_mutex_unlock(&mutex);
	}
}

int main(int argc, const char *argv[])
{
	//定义线程号变量
	pthread_t tid;

	//2、初始化互斥锁
	pthread_mutex_init(&mutex,NULL);

	//创建线程
	if(pthread_create(&tid,NULL,task,NULL)!=0)
	{
		printf("tid create error\n");
		return -1;
	}

	//主线程
	while(1)
	{
		//3、获取锁资源
		pthread_mutex_lock(&mutex);

		//访问临界资源
		printf("主线程  buf=%s\n",buf);
		strcpy(buf,"hello world\n");

		//4、解放锁资源
		pthread_mutex_unlock(&mutex);
	}

	//阻塞回收线程
	pthread_join(tid,NULL);
	
	//5、销毁锁资源
	pthread_mutex_destroy(&mutex);


	return 0;
}

2> 将同步机制代码重新实现一遍

#include<myhead.h>

//1、创建一个无名信号量
sem_t sem;

//生产者线程
void *task1(void *arg)
{
	while(1)
	{
		sleep(2);
		printf("生产一辆车\n");

		//4、释放资源
		sem_post(&sem);
	}
}

//消费者线程
void *task2(void *arg)
{
	while(1)
	{
		//3、申请资源，如果没有资源(val=0)，则在此处阻塞；申请到资源(val=1)，执行下方程序，并使val=0
		sem_wait(&sem);

		printf("消费一辆车\n");
	}
}



int main(int argc, const char *argv[])
{
	//创建两个线程
	pthread_t tid1, tid2;
	
	//2、初始化无名信号量
	sem_init(&sem,0,0);

	//创建生产者线程
	if(pthread_create(&tid1, NULL, task1, NULL) !=0)
	{
		printf("tid1 create error\n");
		return -1;
	}

	//创建消费者线程
	if(pthread_create(&tid2, NULL, task2, NULL) !=0)
	{
		printf("tid2 create error\n");
		return -1;
	}

	//主线程回收资源
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);

	//5、销毁无名信号量
	sem_destroy(&sem);

	return 0;
}

3> 使用三个线程完成两个文件的拷贝，线程1完成拷贝前一半，线程2完成拷贝后一半，主线程回收两个分支线程的资源

#include<myhead.h>
typedef struct File
{
	const char *srcfd;
	const char *dstfd;
}file;
//文件大小，共享资源
int size;

//1、创建一个互斥锁
pthread_mutex_t mutex;

//以只读形式打开srcfile，以只写创建清空打开目标文件
int open_file(file *fd)
{
	//定义两个文件描述符
	int srcfd, dstfd;

	//以只读打开源文件
	if((srcfd=open(fd->srcfd,O_RDONLY)) == -1)
	{
		perror("open srcfile error\n");
		return -1;
	}

	//以只写创建或清空目标文件
	if((dstfd=open(fd->dstfd,O_WRONLY|O_CREAT|O_TRUNC,0664))==-1)
	{
		perror("open dstfile error\n");
		return -1;
	}

	//计算源文件大小
	size=lseek(srcfd, 0, SEEK_END);

	//关闭文件
	close(srcfd);
	close(dstfd);
}

//定义分支线程1
void *task1(void *arg)
{
	file* fd= (file*)arg;
	//3、获取锁资源
	pthread_mutex_lock(&mutex);

	int srcfd, dstfd;
	//以只读打开源文件
	if((srcfd=open(fd->srcfd,O_RDONLY)) == -1)
	{
		perror("open srcfile error\n");
	}

	//以只写形式打开目标文件
	if((dstfd=open(fd->dstfd,O_WRONLY))==-1)
	{
		perror("open dstfile error\n");
	}

	char buf[128]="";
	int sum = 0;
	//循环遍历拷贝前半段
	while(1)
	{
		int res = read(srcfd,buf,sizeof(buf));
		sum += res;
		if(sum >= (size/2))
		{
			write(dstfd,buf,res-(sum-size/2));
			break;
		}
		write(dstfd,buf,res);
	}

	//关闭文件
	close(srcfd);
	close(dstfd);

	//4、释放锁资源
	pthread_mutex_unlock(&mutex);
}

//定义分支线程2
void *task2(void *arg)
{
	file *fd=(file*)arg;
	//3、获取锁资源
	pthread_mutex_lock(&mutex);

	int srcfd, dstfd;

	//以只读打开源文件
	if((srcfd=open(fd->srcfd,O_RDONLY)) == -1)
	{
		perror("open srcfile error\n");
	}

	//以只写形式打开目标文件
	if((dstfd=open(fd->dstfd,O_WRONLY))==-1)
	{
		perror("open dstfile error\n");
	}

	char buf[128]="";
	int sum = size/2;
	
	//移动光标
	lseek(srcfd,size/2,SEEK_SET);
	lseek(dstfd,size/2,SEEK_SET);

	//循环遍历拷贝后半段
	while(size != sum)
	{
		int res = read(srcfd,buf,sizeof(buf));
		write(dstfd,buf,res);
		sum += res; 
	}
	//关闭文件
	close(srcfd);
	close(dstfd);

	//4、释放锁资源
	pthread_mutex_unlock(&mutex);


}



/********************主程序*****************/
int main(int argc, const char *argv[])
{
	//定义结构体来传参
	file *arg;
	arg->srcfd=argv[1];
	arg->dstfd=argv[2];

	//创建文件
	open_file(arg);

	//判断外部传参
	if(argc != 3)
	{
		printf("input file error\n");
		printf("usage: ./a.out srcfile dstfile\n");
		return -1;
	}
	//定义两个线程变量
	pthread_t tid1, tid2;

	//2、初始化互斥锁
	pthread_mutex_init(&mutex,NULL);

	//创建线程1
	if(pthread_create(&tid1, NULL, task1, arg) != 0)
	{
		printf("tid1 create error\n");
		return -1;
	}

	//创建线程2
	if(pthread_create(&tid2, NULL, task2, arg) != 0)
	{
		printf("tid2 create error\n");
		return -1;
	}

	//主线程
	//阻塞回收资源
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);

	//销毁锁资源
	pthread_mutex_destroy(&mutex);
	
	return 0;
}

4> 使用三个线程完成：线程1输出字符'A',线程2输出字符'B',线程3输出字符'C',要求输出结果为：ABCABCABCABCABC...

#include<myhead.h>

//创建一个无名信号量
sem_t sem;

//创建计数器
int count=0;

//线程1
void* task1(void *arg)
{
	while(1)
	{
		if(count%3==0)
		{
			printf("A");
			count++;
		}
		//释放资源
		sem_post(&sem);
	}
}

//线程2
void* task2(void *arg)
{
	while(1)
	{
		//申请资源
		sem_wait(&sem);

		if(count%3==1)
		{
			printf("B");
			count++;
		}

		//释放资源
		sem_post(&sem);
	}
}

//线程3
void* task3(void *arg)
{
	while(1)
	{
		//申请资源
		sem_wait(&sem);
		if(count%3==2)
		{
			printf("C");
			count++;
		}

		//释放资源
		sem_post(&sem);
	}
}

/*********************主函数*********************/
int main(int argc, const char *argv[])
{
	//定义两个线程变量
	pthread_t tid1, tid2, tid3;

	//初始化无名信号量
	sem_init(&sem,0,0);
	
	//创建线程1
	if(pthread_create(&tid1, NULL, task1, NULL) != 0)
	{
		printf("tid1 create error\n");
		return -1;
	}

	//创建线程2
	if(pthread_create(&tid2, NULL, task2, NULL) != 0)
	{
		printf("tid2 create error\n");
		return -1;
	}
	
	//创建线程3
	if(pthread_create(&tid3, NULL, task3, NULL) != 0)
	{
		printf("tid3 create error\n");
		return -1;
	}

	//主线程
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	pthread_join(tid3,NULL);

	//销毁无名信号量
	sem_destroy(&sem);
	return 0;
}