23111 IO进程线程 day5

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

#include<myhead.h>

char buf[128];

//定义互斥锁变量
pthread_mutex_t mutex;

//创建分支线程函数
void *task(void *arg)
{
	while(1)
	{
		//获取锁资源
		pthread_mutex_lock(&mutex);

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

		//释放互斥锁资源
		pthread_mutex_unlock(&mutex);
	}
}

int main(int argc, const char *argv[])
{
	pthread_t tid=0;

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

	//创建线程
	tid=pthread_create(&tid,NULL,task,NULL);

	if(tid!=0)
	{
		printf("tid create error\n");
		return -1;
	}

	while(1)
	{
		//获取锁资源
		pthread_mutex_lock(&mutex);

		printf("主线程中buf=%s\n",buf);
		strcpy(buf,"hello world\n");

		//释放互斥锁资源
		pthread_mutex_unlock(&mutex);
	}

	//阻塞回收线程
	pthread_join(tid,NULL);

	//销毁互斥锁
	pthread_mutex_destroy(&mutex);

	return 0;
}

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

#include<myhead.h>

//定义一个无名变量
sem_t sem;

//生产函数
void *task1(void *arg)
{
	while(1)
	{
		printf("我生产了一辆车\n");
		sleep(2);

		//释放无名变量的资源
		sem_post(&sem);
	}
}

//消费函数
void *task2(void *arg)
{
	while(1)
	{
		//申请无名变量的资源
		sem_wait(&sem);

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


int main(int argc, const char *argv[])
{
	pthread_t tid1,tid2;

	//初始化无名变量
	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);

	//销毁无名变量的资源
	sem_destroy(&sem);

	return 0;
}

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

#include<myhead.h>

//定义一个结构体
typedef struct 
{
	const char *src;//源文件的地址
	const char *dst;//目标文件的地址
	int start;      //文件的光标位置
	int len;        //文件的长度
}info_t;

//计算文件长度
int file_len(const char *srcfile,const char * dstfile)
{
    int sfd,dfd;
    int len=0;

	//以只读的形式打开源文件
    if((sfd=open(srcfile,O_RDONLY))==-1)
    {
        perror("open srcfile error");
		return -1;
    }

	//以读写的形式打开目标文件
    if((dfd=open(dstfile,O_RDWR|O_CREAT|O_TRUNC,0664))==-1)
    {
        perror("open dstfile error");
		return -1;
    }

	//计算源文件长度
    len=lseek(sfd,0,SEEK_END);       

	//关闭文件
    close(sfd);
    close(dfd);

    return len;
}

int copy_file(const char *srcfile,const char * dstfile,int start,int len)
{
    int sfd,dfd;
    char buf[128] = "";
    int res=0;
	int sum=0;

	//以只写的形式打开源文件
    if((sfd = open(srcfile,O_RDONLY))==-1)
    {
        perror("open srcfile error");
		return -1;
    }

	//以读写的形式打开目标文件
    if((dfd = open(dstfile,O_RDWR))==-1)
    {
        perror("open dstfile error");
		return -1;
    }
	
	//将文件光标定位在start处
    lseek(sfd,start,SEEK_SET);
    lseek(dfd,start,SEEK_SET);

    while(1)
	{
		//读取源文件
        res= read(sfd,buf,sizeof(buf));
		//计算读取的文件字节总长度
		sum+=res;
		if(res==0 || sum>len) 
		{
			//写入最后一次读取的内容
			write(dfd,buf,res-(sum-len));
			break;
		}
		//将内容写入目标文件
		write(dfd,buf,res);
    }

	//关闭文件
    close(sfd);
    close(dfd);
    return 0;
}

//分支线程函数
void *task(void *arg)
{
	info_t f=*(info_t *)arg;
    copy_file(f.src,f.dst,f.start,f.len);
    pthread_exit(NULL);
}

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

	int len;

	//判断是否外部传参
	if(argc!= 3)
	{
        printf("input error,try again\n");
        printf("usage:./a.out srcfile dstfile\n");
        return 0;
    }

	//计算文件长度
	len=file_len(argv[1],argv[2]);

	info_t f[2]={{argv[1],argv[2],0,len/2},{argv[1],argv[2],len/2,(len-len/2)}};

	//创建两个线程
	if(pthread_create(&tid1,NULL,task,(void*)&f[0])!=0)
	{
		printf("tid1 create error\n");
		return -1;
	}
	if(pthread_create(&tid2,NULL,task,(void*)&f[1])!=0)
	{
		printf("tid2 create error\n");
		return -1;
	}
	
	printf("拷贝成功\n");

	//结束线程
	pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
	return 0;
}

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

#include<myhead.h>

//定义无名变量
sem_t sem1;
sem_t sem2;
sem_t sem3;

//线程1
void *task1(void *arg)
{
	while(1)
	{
		//申请C资源
		sem_wait(&sem3);

		printf("A");

		//释放A资源
		sem_post(&sem1);	
	}
}
//线程2
void *task2(void *arg)
{
	while(1)
	{
		//申请A资源
		sem_wait(&sem1);

		printf("B");

		//释放B资源
		sem_post(&sem2);
	}
}
//线程3
void *task3(void *arg)
{
	while(1)
	{
		//申请B资源
		sem_wait(&sem2);

		printf("C");

		//释放C资源
		sem_post(&sem3);	
	}
}

int main(int argc, const char *argv[])
{
	pthread_t tid1,tid2,tid3;

	//初始化无名变量
	sem_init(&sem1,0,0);
	sem_init(&sem2,0,0);
	sem_init(&sem3,0,1);

	//创建线程
	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;
	}

	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(&sem1);
	sem_destroy(&sem2);
	sem_destroy(&sem3);
	return 0;
}

思维导图