1.5 第二章+第三章 进程线程基础+进程线程间的通信

思维导图

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

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<header.h>
char buf[128];//定义一个全局变量
//1.定义锁资源
pthread_mutex_t mutex;
//子线程
void *task(void *arg)
{
	while(1)
	{
		sleep(1);
		//3.获取锁资源
		pthread_mutex_lock(&mutex);
		printf("子线程中buf=%s\n",buf);
		strcpy(buf,"I love China");
		//释放锁资源
		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)
	{
		puts("tid create error");
		return -1;
	}
	//主线程
	while(1)
	{
		sleep(1);
		//3.获取锁资源
		pthread_mutex_lock(&mutex);
		printf("主线程中buf=%s\n",buf);
		strcpy(buf,"hello world");
		//释放锁资源
		pthread_mutex_unlock(&mutex);
	}
	//回收资源
	pthread_join(tid,NULL);
	return 0;
}

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

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<header.h>
//定义无名信号量
sem_t sem;
//生产者线程
void *task1(void *arg)
{
	while(1)
	{
		sleep(1);
		puts("我生产了一辆特斯拉");
		//释放资源
		sem_post(&sem);
	}
}
//消费者线程
void *task2(void *arg)
{
	while(1)
	{
		sleep(1);
		//申请资源，如果没有资源，则在该处阻塞
		sem_wait(&sem);
		puts("我消费了一辆特斯拉");
	}
}
int main(int argc, const char *argv[])
{
	//创建两个线程
	pthread_t tid1,tid2;
	//初始化无名信号量
	sem_init(&sem,0,0);
	//创建生产者线程
	if(pthread_create(&tid1,NULL,task1,NULL)!=0)
	{
		puts("error");
		return -1;
	}
	//创建消费者线程
	if(pthread_create(&tid2,NULL,task2,NULL)!=0)
	{
		puts("error");
		return -1;
	}
	//主线程回收资源
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	//销毁无名信号量
	sem_destroy(&sem);
	return 0;
}

3.使用3个线程完成2个文件的拷贝，线程1完成拷贝前一半，线程2拷贝后一半，主线程回收2个子线程的资源

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<header.h>
struct INFO
{
	const char *r;	//读取的文件
	const char *w;	//写入的文件
	int start;	//开始位置
	int len;	//长度
};
//定义求文档长度函数
int lenstr(const char *r)
{
	//以只读的形式打开源文件
	FILE *rfp=NULL;
	if((rfp=fopen(r,"r"))==NULL)
	{
		perror("rfp error");
		return -1;
	}
	//使用fseek和ftell函数定位到文件的数量
	//fseek(文件指针，偏移量，开始的位置)
	//ftell(文件中指针)，直接返回文件的位置，既把指针最后的位置，返回文件数量
	int len=0;    //计数	
	fseek(rfp,0,SEEK_END);	//光标偏移到文件最后的位置
	len=ftell(rfp);   //返回值就是文件的数量
	fclose(rfp);
	return len;
}
//定义拷贝函数
int file_cpy(const char *r,const char *w,int start, int len)
{	
	char buf[128]="";
	//以只读的形式打开源文件
	FILE *rfp=NULL;
	if((rfp=fopen(r,"r"))==NULL)
	{
		perror("rfp error");
		return -1;
	}
	//以追加写的形式打开被写的文件
	FILE *wfp=NULL;
	if((wfp=fopen(w,"a"))==NULL)
	{
		perror("wfp error");
		return -1;
	}
    //光标定位到开始偏移的位置
	fseek(rfp,start,SEEK_SET); 
	//由于需要限制位置，所以使用fread函数来进行读取
	int count=fread(buf,sizeof(buf[0]),len,rfp);
	//写入使用fwrite函数
	fwrite(buf,sizeof(buf[0]),count,wfp);
	//关闭文件
	fclose(rfp);
	fclose(wfp);
	return 0;
}
void *task1(void *arg)
{
	while(1)
	{
		
	struct INFO * fap = (struct INFO *)arg;
	//调用文件拷贝函数进行拷贝
	file_cpy(fap->r,fap->w,fap->start,fap->len);		
		printf("我是分支线程1\n");
		sleep(1);
		//将输入的拷贝函数的各个参数分解
		//将输入的拷贝函数的各参数结构体拆包到一个结构体变量中
		//获取当前线程的线程号
		printf("分支线程1:tid1=%#lx\n",pthread_self());
		//退出当前线程
		printf("分支线程1资源退出\n");
		pthread_exit(NULL);
	}
}
void *task2(void *arg)
{
	while(1)
	{
		printf("分支线程2\n");
		sleep(1);
		//将输入的拷贝函数的各个参数分解
		struct INFO * fap = (struct INFO *)arg;
	    //拷贝
	    file_cpy(fap->r,fap->w,fap->start,fap->len);	
		printf("分支线程1:tid1=%#lx\n",pthread_self());
		//退出当前线程
		printf("分支线程2资源退出\n");
		pthread_exit(NULL);	
	}
}
int main(int argc, const char *argv[])
{
	if(argc!=3)
	{
		printf("error\n");
		return -1;
	}
	int len=lenstr(argv[1]);
	//定义结构体变量
	struct INFO t1={argv[1],argv[2],0,len/2};
	struct INFO t2={argv[1],argv[2],len/2,len-len/2};
	//定义一个线程号变量
	pthread_t tid1=0;	
	//创建出分支线程
	if(pthread_create(&tid1,NULL,task1,&t1)!=0)
	{
		printf("tid1 create error\n");
		return -1;
	}
	printf("tid1 create success tid=%#lx\n",tid1);
	pthread_t tid2=0;
	if(pthread_create(&tid2,NULL,task2,&t2)!=0)
	{
		printf("tid2 create error\n");
		return -1;
	}
	printf("tid2 create success tid2=%#lx\n",tid2);
//	while(1)
	{
		printf("主线程\n");
		sleep(1);
	}
	//回收分支线程资源
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	printf("回收资源结束\n");
	return 0;
}

4.使用3个线程完成：线程1输出字符'A'，线程2输出字符'B'，线程3输出字符'C'，要求输出结果为：ABCABCABC……

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<header.h>
//定义无名信号量
sem_t sem;
//线程1
void *task(void *arg)
{
	//接收字符
	char buf=*(char*)arg;
	while(1)
	{
		//申请资源，如果没有资源，则在该处阻塞
		sem_wait(&sem);
		sleep(1);
		printf("%c",buf);
		//手动刷新
		fflush(stdout);
		//释放资源
		sem_post(&sem);
		usleep(10000);
	}
}
int main(int argc, const char *argv[])
{
	//创建3个线程
	pthread_t tid1,tid2,tid3;
	//创建字符变量
	char a='A',b='B',c='C';
	//初始化无名信号量
	sem_init(&sem,0,1);
	//创建线程1
	if(pthread_create(&tid1,NULL,task,&a)!=0)
	{
		puts("tid1 create error");
		return -1;
	}
	//创建线程2
	if(pthread_create(&tid2,NULL,task,&b)!=0)
	{
		puts("tid2 create error");
		return -1;
	}
	//创建线程3
	if(pthread_create(&tid3,NULL,task,&c)!=0)
	{
		puts("tid3 create error");
		return -1;
	}
	//主线程回收资源
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	pthread_join(tid3,NULL);
	//销毁
	sem_destroy(&sem);
	return 0;
}