IO DAY4

1.

代码：

#include <myhead.h>
int a=0;
//定义互斥锁
pthread_mutex_t mutex;
void *task(void *argc)
{
    while(1)
    {
        //或取锁资源
        pthread_mutex_lock(&mutex);
        a=1;
        printf("a=%d\n",a);
        //释放锁资源
        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)
    {
        printf("create error\n");
        return -1;
    }
    while(1)
    {
        pthread_mutex_lock(&mutex);
        a=100;
        printf("a=%d\n",a);
        pthread_mutex_unlock(&mutex);
    }
    pthread_join(tid,NULL);
    //销毁锁资源
    pthread_mutex_destroy(&mutex);
    return 0;
}
                                  

运行结果：

2.

代码：

#include <myhead.h>
sem_t sem;
void *task1(void *argc)
{
	while(1)
	{
		sleep(1);
		printf("生产成功一次\n");
		//释放资源
		sem_post(&sem);
	}
}
void *task2(void *arg)
{
	while(1)
	{
		sem_wait(&sem);
        sleep(1);
		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("create error\n");
		return -1;
	}
	if(pthread_create(&tid2,NULL,task2,NULL)!=0)
	{
		printf("create error\n");
		return -1;
	}
	pthread_jion(tid1,NULL);
	pthread_jion(tid2,NULL);
	sem_destroy(&sem);
	return 0;
}

运行结果：

3.

代码：

#include<myhead.h>
//定义求源文件大小的函数
int get_file_len(const char *srcfile)
{
    int srcfd;           //定义文件描述符

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

    //求文件内容大小
    int len = lseek(srcfd, 0, SEEK_END);

    //关闭文件后返回
    close(srcfd);
    return len;
}

//定义拷贝文件函数
int copy_file(const char *srcfile, const char *dstfile, int start, int len)
{
    int srcfd,dstfd;         //定义两个文件描述符变量

    //以只读的形式打开源文件
    if((srcfd=open(srcfile, O_RDONLY)) == -1)
    {
        perror("srcfile open error");
        return -1;
    }
    //以只写的形式打开目标文件
    if((dstfd=open(dstfile, O_WRONLY)) == -1)
    {
        perror("dstfile open error");
        return -1;
    }

    //将两个文件同时定位到start处
    lseek(srcfd, start, SEEK_SET);
    lseek(dstfd, start, SEEK_SET);

    //循环将源文件中的len个字节拷贝到目标文件中
    char buf[128] = "";          //字符搬运工
    int res = 0;                 //每次成功读取的字符个数
    int sum = 0;                  //记录读取字符的总个数

    while(1)
    {
        res = read(srcfd, buf, sizeof(buf));           //从源文件中读取内容
        sum += res;            //将每次读取的字符个数累加
        if(sum >= len || res == 0)
        {
            write(dstfd, buf, res-(sum-len));    //将最后一点数据写入到源文件
            break;
        }
        write(dstfd, buf, res);                         //将读取的数据拷贝到目标文件中
    }


    //关闭两个文件
}



/**************************主程序*********************************/
int main(int argc, const char *argv[])
{
    //判断外部传参
    if(argc != 3)
    {
        printf("input file error\n");
        printf("usage: ./a.out srcfile dstfile\n");
        return -1;
    }

    //定义进程号变量
    pid_t pid1 = -1;

    //求出源文件的大小
    int len = get_file_len(argv[1]);

    //创建子进程
    pid1 = fork();
    if(pid1 == 0)
    {
        //子进程1

        //执行拷贝内容
        //从源文件中拷贝内容到目标文件中，起始位置为0，拷贝len/2
        copy_file(argv[1], argv[2], 0, len/2);
        //退出进程
        exit(EXIT_SUCCESS);

    }else if(pid1 > 0)
    {
        //父进程
        //创建子进程
        pid_t pid2 = fork();
        if(pid2 == 0)
        {
            //子进程2

            //执行拷贝逻辑
            copy_file(argv[1], argv[2], len/2, len-len/2);

            //退出进程
            exit(EXIT_SUCCESS);

        }else if(pid2 > 0)
        {
            //父进程
            //回收子进程资源
            wait(NULL);
            wait(NULL);
        }else 
        {
            perror("pid2 fork error");
            return -1;
        }
    }else
    {
        perror("pid1 fork error");
        return -1;
    }

    printf("拷贝完成\n");
    return 0;
}

运行结果：

4.

代码：

#include<myhead.h>

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

//线程1
void *task1(void *arg)
{
    while(1)
    {
		sem_wait(&sem1);
        sleep(1);
        printf("A\n");
      	//释放资源
        sem_post(&sem2);
    }
}

//线程2
void *task2(void *arg)
{
    while(1) 
    {       
		sem_wait(&sem2);
        sleep(1);
        printf("B\n");
      	//释放资源
        sem_post(&sem3);
    }
}
//线程3
void *task3(void *arg)
{
    while(1) 
    {       
		sem_wait(&sem3);
        sleep(1);
        printf("C\n");
      	//释放资源
        sem_post(&sem1);
    }
}

/********************主线程******************/
int main(int argc, const char *argv[])
{

	sem_init(&sem1, 0, 1);
	sem_init(&sem2, 0, 0);
	sem_init(&sem3, 0, 0);
    //第一个0：表示用于线程之间的通信
    //第二个0：表示value初始值为0

    //创建线程
    pthread_t tid1,tid2,tid3;


    //创建生产者线程
    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);

    //5、销毁无名信号量
    sem_destroy(&sem1);
    sem_destroy(&sem2);
    sem_destroy(&sem3);

    return 0;
}

运行结果：