IO进程线程 2月6日作业

1.

#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#include <string.h>

char buf[128] = "";


//信号量
sem_t sem1, sem2;

void* callBack_read(void* arg)
{
    FILE* fp = fopen("./01_pthread_create.c", "r");
    if(NULL == fp)
    {
        perror("fopen");
        pthread_exit(NULL);                                                                                                                     
    }

    while(1)
    {
        if(sem_wait(&sem1) < 0)     //P操作
        {
            perror("sem_wait");
            break;
        }
        bzero(buf, sizeof(buf));
        if(fgets(buf, sizeof(buf), fp) == NULL)
        {
            break;
        }

        if(sem_post(&sem2) < 0) //V操作 
        {
            perror("sem_post");
            break;
        }

    }
    if(sem_post(&sem2) < 0) //V操作 
    {
        perror("sem_post");
    }


    printf("文件读取完毕\n");
    fclose(fp);
    pthread_exit(NULL);
}

void* callBack_write(void* arg)
{
    while(1)
    {
        if(sem_wait(&sem2) < 0)     //P操作
        {
            perror("sem_wait");
            break;
        }

        if(strlen(buf) == 0)
            break;

        printf("%s", buf);
        fflush(stdout);

        if(sem_post(&sem1) < 0) //V操作 
        {
            perror("sem_post");
            break;
        }
    }
    pthread_exit(NULL);
}


int main(int argc, const char *argv[])
{
    //创建信号量
    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 tid_r, tid_w;
    //一个线程读取
    if(pthread_create(&tid_r, NULL, callBack_read,  NULL) != 0)
    {
        perror("pthread_create");
        return -1;
    }

    //一个线程打印
    if(pthread_create(&tid_w, NULL, callBack_write,  NULL) != 0)
    {
        perror("pthread_create");
        return -1;
    }


    pthread_join(tid_r, NULL);
//  pthread_cancel(tid_w);      //请求写线程退出

    pthread_join(tid_w, NULL);


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

    return 0;
}

2.

#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <unistd.h>
//互斥锁变量方式二
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;//控制线程运行的时机
void* callback1(void* arg)
{
while(1)
{
	/*******临界区************/
	//上锁
pthread_mutex_lock(&mutex);
//如果不是当前线程要访问的时机，则需要让当前线程休眠
if(flag !=0)
{
//1．解开互斥锁，阻塞当前线程，让当前线程进入休眠阶段，等待被唤醒
pthread_cond_wait(&cond1,&mutex);
//2．唤醒成功后，.当cpu再次调度到该线程，会尝试立刻上锁
//3．如果上锁成功，则从当前位置继续往后执行。
//4.如果上锁失败，则在当前函数位置，重新向到cond上继续休眠，等待下一次唤醒。
}
printf("A");
flag = 1;
//唤醒:唤醒睡在指定条件变量上的线程
pthread_cond_signal(&cond2);
//解锁
pthread_mutex_unlock( &mutex);
/******]临界区************/
}
pthread_exit(NULL);
}

void* callback2(void* arg)
{
		while(1)
	{
		/******临界区************/
		//上锁
		pthread_mutex_lock( &mutex);
		//如果不是当前线程要访问的时机，则需要让当前线程休眠
		if(flag != 1)
		{
			//1．解开互斥锁，阻塞当前线程，让当前线程进入休眠阶段，等待被唤醒
			pthread_cond_wait(&cond2,&mutex);
				//2．唤醒成功后，当cpu再次调度到该线程，会尝试立刻上锁
				//3．如果上锁成功，则从当前位置继续往后执行。
				//4.如果上锁失败，则在当前函数位置，重新回到cond上继续休眠，等待下一次唤醒
				//
		}
		printf("B");
		/*	for(int i=0; i<strlen(buf)/2; i++)
		{
			temp = buf[i];
			buf[i] = buf[strlen(buf)-1-i];
			buf[strlen(buf)-1-i] = temp;
		}*/
		flag =2;
		//唤醒:唤醒睡在指定条件变量上的线程
		pthread_cond_signal(&cond3);
		//解锁
		pthread_mutex_unlock( &mutex );
		/******临界区************/
	}
	pthread_exit(NULL);
}
void* callback3(void* arg)
{
while(1)
{
	/*******临界区************/
	//上锁
pthread_mutex_lock(&mutex);
//如果不是当前线程要访问的时机，则需要让当前线程休眠
if(flag !=2)
{
//1．解开互斥锁，阻塞当前线程，让当前线程进入休眠阶段，等待被唤醒
pthread_cond_wait(&cond3,&mutex);
//2．唤醒成功后，.当cpu再次调度到该线程，会尝试立刻上锁
//3．如果上锁成功，则从当前位置继续往后执行。
//4.如果上锁失败，则在当前函数位置，重新向到cond上继续休眠，等待下一次唤醒。
}
printf("C");
putchar(10);
flag = 0;
//唤醒:唤醒睡在指定条件变量上的线程
pthread_cond_signal(&cond1);
//解锁
pthread_mutex_unlock( &mutex);
/******]临界区************/
}
pthread_exit(NULL);
}

int main(int argc, const char *argv[])
{
	/*
	//创建互斥锁:方式一
	if(pthread_mutex_init(&mutex，NULL) != 0)
	{
	fprintf(stderr, "pthread_mutex_init failed _%d__\n"，_LINE__);
	return -1;
	}
	*/
	/*
	   创建条件变量:方式一
	   if(pthread cond_init( &cond，NULL) != 0)
	   {
	   fprintf(stderr， "pthread_cond_init failed__%d___\n"，__LINE_);
	   return -1;
	   }
	   */
	pthread_t A,B,C;
	//创建线程:1
	if(pthread_create(&A,NULL, callback1,NULL) != 0)
	{
		fprintf(stderr, "pthread_create failed\n" );
		return -1;
	}
		//创建线程:2
	if(pthread_create(&B,NULL, callback2,NULL) != 0)
	{
		fprintf(stderr, "pthread_create failed\n" );
		return -1;
	}



	//创建线程:3
	if(pthread_create(&C,NULL, callback3,NULL) != 0)
	{
		fprintf(stderr, "pthread_create failed\n" );
		return -1;
	}
	pthread_detach(A);
	pthread_join(B,NULL);

	pthread_join(C,NULL);
	//销毁互斥锁
	pthread_mutex_destroy(&mutex);
	//销毁条件变量
	pthread_cond_destroy(&cond1);

	pthread_cond_destroy(&cond2);
	pthread_cond_destroy(&cond3);

	return 0;
}

结果