嵌入式学习-IO进程线程-Day5

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,"hello world");
			pthread_mutex_unlock(&mutex);
		}
}
int main(int argc, const char *argv[])
{
	pthread_t tid ;
	
	pthread_mutex_init(&mutex,NULL);
	//创建一个分支线程
	if(pthread_create(&tid,NULL,task,NULL)!=0)
	{
		puts("tid create error");
		return -1;
	}
	
	while(1)
	{
		pthread_mutex_lock(&mutex);
		printf("主线程中buf=%s\n",buf);
		strcpy(buf,"你好世界");
		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)
    {
		sleep(2);
        //申请资源，如果没有资源，则在该处阻塞
        printf("S\n");
        sem_post(&sem);
    }
}

void *task2(void *arg)
{
    while(1)
    {
        sem_wait(&sem);
        printf("A\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>


struct func 
{
	char src[100];
	char dest[100];
	int set;
	int size;
};

int get_file_len(const char *srcfile,const char *destfile)
{
	//定义两个文件描述符
	int srcfd,destfd;

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

	//以只写创建清空的方式打开目标文件
	if((destfd=open(destfile,O_WRONLY|O_CREAT|O_TRUNC,0664))==-1)
	{
		perror("目标文件打开错误");
		return -1;
	}
	int len =lseek(srcfd,0,SEEK_END);
	lseek(srcfd,0,SEEK_SET);
	return len;
}

void *task(void *arg)
{
	//定义两个文件描述符
	int srcfd,destfd;

	if((srcfd=open(((struct func*)arg)->src,O_RDONLY))==-1)
	{
		perror("源文件打开错误");
		return NULL;
	}


	if((destfd=open(((struct func*)arg)->dest,O_WRONLY))==-1)
	{
		perror("目标文件打开错误");
		return NULL;
	}

	lseek(srcfd,((struct func*)arg)->set,SEEK_SET);
	lseek(destfd,((struct func*)arg)->set,SEEK_SET);

	char buf[128]="";
	int res=0;
	int sum=0;
	while(1)
	{
		res=read(srcfd,buf,sizeof(buf));
		sum+=res;
		if(sum>=(((struct func*)arg)->size)||res==0)
		{
			write(destfd,buf,res-sum+(((struct func*)arg)->size));
			break;
		}
		write(destfd,buf,res);
	

	}

	//关闭两个文件
	close(destfd);
	close(srcfd);
	
	pthread_exit(NULL);
}

int main(int argc, const char *argv[])
{
	//判断外部传参
	if(argc!=3)
	{
		printf("输入错误\n");
		printf("格式：./a.out 源文件 目标文件\n");
		return -1;
	}

	int len = get_file_len(argv[1],argv[2]);
	
	//定义一个线程号变量1
	pthread_t tid1;
	
	struct func arg;
	strcpy(arg.src, argv[1]);
	strcpy(arg.dest, argv[2]);
	arg.set = 0;
	arg.size = len/2;

	//创建一个分支线程1
	if(pthread_create(&tid1,NULL,task,&arg)!=0)
	{
		printf("创建失败\n");
		return -1;
	}

	//定义一个线程号变量2
	pthread_t tid2;

	struct func arg2;
	strcpy(arg2.src, argv[1]);
	strcpy(arg2.dest, argv[2]);
	arg2.set = len/2;
	arg2.size = len - len/2;

	//创建一个分支线程2
	if(pthread_create(&tid2,NULL,task,&arg2)!=0)
	{
		printf("创建失败\n");
		return -1;
	}
	
	//主线程回收资源
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	printf("分支线程已全部回收\n");

	printf("拷贝成功\n");


	return 0;
}

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

代码

#include<myhead.h>

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

void *task1(void *arg)
{
    while(1)
    {
        //申请资源，如果没有资源，则在该处阻塞
		sem_wait(&sem);
        printf("A");
		fflush(stdout);
        sem_post(&sem1);
    }
}

void *task2(void *arg)
{
    while(1)
    {
        sem_wait(&sem1);
        printf("B");
		fflush(stdout);
        sem_post(&sem2);

    }
}


void *task3(void *arg)
{
    while(1)
    {
        sem_wait(&sem2);
        printf("C");
		fflush(stdout);
		sem_post(&sem);

    }
}


int main(int argc, const char *argv[])
{
    //创建两个线程
    pthread_t tid1,tid2,tid3;

    //初始化无名信号量
    sem_init(&sem, 0, 1);
    sem_init(&sem1, 0, 0);
    sem_init(&sem2, 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;
    }
    
	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);
    sem_destroy(&sem1);
    sem_destroy(&sem2);

    return 0;
}