5.10作业

1用两个线程拷贝一张图片。A线程拷贝前半部分，B线程拷贝后半部分，要求如下：

只开一份资源，即每个文件只open一次。

不能使用wait和sleep函数。

提示：先找临界资源，再找临界区，对临界区上锁

​
#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <semaphore.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>

struct info
{
	int fd;
	off_t size;

};

//临界资源
char a=0;
int len=0;

sem_t sem1, sem2;

void* callBack1(void* arg)//读
{

	int fd=((struct info*)arg)->fd;
    while(1)
    {
        /临界区
        //P操作:
        sem_wait(&sem1);
		lseek(fd,len,SEEK_SET);
		int ret=read(fd,&a,1);
		if(ret==0)	
		   {
		   		pthread_exit(NULL);
		   }                         //读一个字符
		len++;
        //v操作 
        sem_post(&sem2);
        /临界区
    }
}


void* callBack2(void* arg)//写
{                                                                                                  
    char temp = 0;
    while(1)
    {
        /临界区
        //P操作
        sem_wait(&sem2);
		write(1,&a,1);
		if(len==((struct info*)arg)->size)
		{
		   		pthread_exit(NULL);
		}
        //v操作 
        sem_post(&sem1);
        /临界区
    }
}


int main(int argc, const char *argv[])
{
	pid_t pid=fork();
	if(pid>0)
	{
		int fd=open("./daiying_zuoye.c",O_RDONLY);
		if(fd<0)
		{
			perror("open");
			return -1;
		}
		off_t size=lseek(fd,0,SEEK_END);
		struct info file;
		file.fd=fd;
		file.size=size;
    //创建信号量
    if(sem_init(&sem1, 0, 1) < 0)
    {
        perror("sem_init");
        return -1;
    }
    if(sem_init(&sem2, 0, 0) < 0)
    {
        perror("sem_init");
        return -1;
    }



    pthread_t tid1, tid2;
    if(pthread_create(&tid1, NULL, callBack1, (void*)&file) != 0)
    {
        fprintf(stderr, "pthread_create failed %d\n", __LINE__);
        return -1;
    }
    pthread_detach(tid1);

    if(pthread_create(&tid2, NULL, callBack2,(void *)&file) != 0)
    {
        fprintf(stderr, "pthread_create failed %d\n", __LINE__);
        return -1;
    }

    //pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

    //销毁信号量
    sem_destroy(&sem1);
    sem_destroy(&sem2);
	}
    return 0;
}


​

2现有ID号为a b c的三个线程，每个线程的任务都是循环打印自己id号，要求打印的顺序为abc

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
//条件变量
pthread_cond_t cond1 = PTHREAD_COND_INITIALIZER;

pthread_cond_t  cond2= PTHREAD_COND_INITIALIZER;
pthread_cond_t  cond3= PTHREAD_COND_INITIALIZER;

int flag = 0;   //0:打印， 1:去倒置     限制线程访问时机

void* callBack1(void* arg)
{
    while(1)
    {   
        /临界区
        //上锁
        pthread_mutex_lock(&mutex);

        if(flag != 0)
        {
            //解开互斥锁，设置一个条件变量，同时阻塞当前线程，
            //等待被唤醒                                                      
            pthread_cond_wait(&cond1, &mutex);
            //立即尝试上锁，
            //如果上锁成功，则从当前位置继续往后执行。
            //如果上锁失败，则重新回到cond上继续休眠，等待下一次唤醒
        }

        putchar('a');
        flag = 1;

        //唤醒睡在指定条件变量上的线程
        pthread_cond_signal(&cond2);
        //目前只要理解，唤醒后，睡在cond上的线程肯定能够立刻上锁即可
        //解锁
        pthread_mutex_unlock(&mutex);
        /临界区
    }   
}


void* callBack2(void* arg)
{
    while(1)
    {   
        /临界区
        //上锁
        pthread_mutex_lock(&mutex);

        if(flag != 1)
        {
            //解开互斥锁，设置一个条件变量，同时阻塞当前线程，
            //等待被唤醒
            pthread_cond_wait(&cond2, &mutex);
            //立即尝试上锁，
            //如果上锁成功，则从当前位置继续往后执行。
            //如果上锁失败，则重新回到cond上继续休眠，等待下一次唤醒
        }
		putchar('b');	
        

        flag = 2;

        //唤醒睡在指定条件变量上的线程
        pthread_cond_signal(&cond3);
        //目前只要理解，唤醒后，睡在cond上的线程肯定能够立刻上锁即可
        //解锁
        pthread_mutex_unlock(&mutex);
        /临界区
    }   
}

void* callBack3(void* arg)
{
    while(1)
    {   
        /临界区
        //上锁
        pthread_mutex_lock(&mutex);

        if(flag != 2)
        {
            //解开互斥锁，设置一个条件变量，同时阻塞当前线程，
            //等待被唤醒
            pthread_cond_wait(&cond3, &mutex);
            //立即尝试上锁，
            //如果上锁成功，则从当前位置继续往后执行。
            //如果上锁失败，则重新回到cond上继续休眠，等待下一次唤醒
        }
		putchar('c');	
      

        flag = 0;

        //唤醒睡在指定条件变量上的线程
        pthread_cond_signal(&cond1);
        //目前只要理解，唤醒后，睡在cond上的线程肯定能够立刻上锁即可
        //解锁
        pthread_mutex_unlock(&mutex);
        /临界区
	}
}


int main(int argc, const char *argv[])
{
    //创建互斥锁 方式1
    //pthread_mutex_init(&mutex, NULL);
    

    /*  
    //创建条件变量
    if(pthread_cond_init(&cond, NULL) != 0)
    {
        fprintf(stderr, "pthread_cond_init failed %d\n", __LINE__);
        return -1;
    }
    */

    pthread_t tid1, tid2,tid3;

    if(pthread_create(&tid1, NULL, callBack1, NULL) != 0)
    {   
        fprintf(stderr, "pthread_create failed %d\n", __LINE__);
        return -1; 
    }   
    pthread_detach(tid1);

    if(pthread_create(&tid2, NULL, callBack2, NULL) != 0)
    {   
        fprintf(stderr, "pthread_create failed %d\n", __LINE__);
        return -1; 
    }   

	if(pthread_create(&tid3, NULL, callBack3, NULL) != 0)
	{
		fprintf(stderr,"pthread_create failed %d\n",__LINE__);
		return -1;
	}

    //pthread_join(tid1, NULL);
    pthread_join(tid3, NULL);

    //销毁互斥锁
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond1);
    pthread_cond_destroy(&cond2);
    pthread_cond_destroy(&cond3);
    return 0;
}