IO进程线程的通信操作

紫枫、苏

已于 2024-02-23 09:39:38 修改

阅读量341

点赞数 2

文章标签： IO进程

于 2024-02-22 23:18:33 首次发布

本文链接：https://blog.csdn.net/2301_81513928/article/details/136242046

版权

1.编程实现互斥机制

程序代码：

  1 #include<myhead.h>
  2 int num=520;//临界资源
  3 //1.创建一个互斥锁变量
  4 pthread_mutex_t mutex;//定义一个pthread_mutex_t类型的变量
  5 //定义任务1函数
  6 void *task1(void *arg)
  7 {
  8     printf("不畏过去\n");
  9     //获取锁资源
 10     pthread_mutex_lock(&mutex);//互斥锁地址
 11     num=1314;
 12     sleep(3);
 13     printf("task1:num=%d\n",num);
 14     //释放锁资源
 15     pthread_mutex_unlock(&mutex);//互斥锁地址
 16 }
 17 //定义任务2函数
 18 void *task2(void *arg)
 19 {
 20     printf("不惧将来\n");
 21     //获取锁资源
 22     pthread_mutex_lock(&mutex);
 23     num++;   //521
 24     sleep(1);  //休眠，执行任务一的赋值语句num=1314
 25     //遇到任务1中的互斥锁，回到这等休眠结束，执行任务二所有程序
 26     printf("task2:num=%d\n",num);
 27     //释放锁资源
 28     pthread_mutex_unlock(&mutex);
 29     //释放完再回到任务一的互斥锁位置，执行任务一所以程序
 30 }
 31 int main(int argc, const char *argv[])
 32 {
 33     //2.初始化互斥锁
 34     pthread_mutex_init(&mutex,NULL);//互斥锁地址，互斥锁属性，成败返回0
 35     //创建两个线程
 36     pthread_t tid1,tid2;//线程号变量
 37     if(pthread_create(&tid1,NULL,task1,NULL)!=0)
 38     //创建分支线程，成0败错误码(不是置位错误码)
 39    //线程号指针，线程属性，线程体(函数指针)，线程体的参数
 40     {
 41         printf("tid1 create error\n");//是POSIX库错误码，不能用ferror()
 42         return 0;
 43     }
 44     if(pthread_create(&tid2,NULL,task2,NULL)!=0)
 45     {
 46         printf("tid2 create error\n");
 47         return 0;
 48     }
 49     printf("tid1:%#lx,tid2:%#lx\n",tid1,tid2);//线程号
 50     //回收线程资源
 51     pthread_join(tid1,NULL);//阻塞等待指定线程的退出，收尸，成0败错误码
 52     pthread_join(tid2,NULL);//要回收的线程号，要回收的线程退出时的状态，NULL
 53     //销毁锁资源
 54     pthread_mutex_destroy(&mutex);//互斥锁指针
 55     return 0;
 56 }

运行结果：

2.编程实现无名信号量

（1）生产和销售

程序代码：

  1 #include<myhead.h>
  2 //1.创建无名信号量
  3 sem_t sem;//定义一个sem_t类型的变量
  4 //定义生产线程
  5 void *task1(void *arg)
  6 {
  7     int num=5;//定义循环量
  8     while(num--)
  9     {
 10         sleep(1);
 11         printf("生产三蹦子\n");
 12         //4.释放资源
 13         sem_post(&sem);//释放无名信号量资源，value加1，
 14         //无名信号量地址
 15     }
 16     //退出线程
 17     pthread_exit(NULL);//线程退出时状态，NULL
 18 }
 19 //定义消费线程
 20 void *task2(void *arg)
 21 {
 22     int num=5;
 23     while(num--)
 24     {
 25         //3.申请资源
 26         sem_wait(&sem);//申请资源，value减1，为0时阻塞，无名信号量地址
 27         printf("消费三蹦子\n");
 28     }
 29     pthread_exit(NULL);
 30 }
 31 int main(int argc, const char *argv[])
 32 {
 33     //2.初始化无名信号量
 34     sem_init(&sem,0,0);
 35     //无名信号量地址，0线程间同步，当前无名信号量维护的value值初始值
 36     //创建两个线程，生产和消费
 37     pthread_t tid1,tid2;
 38     if(pthread_create(&tid1,NULL,task1,NULL)!=0)
 39     //线程号指针，线程属性，线程体(函数体)，线程体的参数
 40     //成0败POSIX库中错误码，不能perror()
 41     {
 42         printf("tid1 create error\n");
 43         return 0;
 44     }
 45     if(pthread_create(&tid2,NULL,task2,NULL)!=0)
 46     {
 47         printf("tid2 create error\n");
 48         return 0;
 49     }
 50     printf("tid1:%#lx,tid2:%#lx\n",tid1,tid2);
 51     //回收线程资源
 52     pthread_join(tid1,NULL);//阻塞等待指定线程退出，收尸
 53     pthread_join(tid2,NULL);//要回收的线程号、要回收线程退出时状态
 54     //释放无名信号量
 55     sem_destroy(&sem);//无名信号量地址
 56     return 0;
 57 }

运行结果：

（2）创建三个线程，线程1打印A，线程2打印B，线程3打印C

程序代码：

  1 #include<myhead.h>
  2 //创建无名信号量
  3 sem_t sem1,sem2,sem3;
  4 //定义线程1
  5 void *task1(void *arg)
  6 {
  7     int num=3;
  8     while(num--)
  9     {
 10         //3.申请资源
 11         sem_wait(&sem1);
 12         sleep(1);
 13         printf("A\t");
 14         //刷新给定文件指针缓冲区，要刷新的缓冲区
 15         //stdout标准输出指针
 16         fflush(stdout);
 17         //4.释放资源
 18         sem_post(&sem2);//释放无名信号量sem2的资源，value加1
 19     }
 20     //退出线程
 21     pthread_exit(NULL);
 22 }
 23 //定义线程2
 24 void *task2(void *arg)
 25 {
 26     int num=3;
 27     while(num--)
 28     {
 29         sem_wait(&sem2);//sem2资源-1
 30         sleep(1);
 31         printf("B\t");
 32         fflush(stdout);//输出没有\n，不刷新不会打印出来，等全部运行结束直接给出结果
 33         sem_post(&sem3);//sem3资源+1，sem3才能接着用
 34     }
 35     pthread_exit(NULL);
 36 }
 37 //定义线程3
 38 void *task3(void *arg)
 39 {
 40     int num=3;
 41     while(num--)
 42     {
 43         //申请资源sem3
 44         sem_wait(&sem3);
 45         sleep(1);
 46         printf("C\t");
 47         fflush(stdout);
 48         sem_post(&sem1);//释放sem1资源，
 49     }
 50     pthread_exit(NULL);
 51 }
 52 int main(int argc, const char *argv[])
 53 {
 54     //初始化无名信号量
 55     sem_init(&sem1,0,1);//无名信号量地址
 56     sem_init(&sem2,0,0);//0线程同步
 57     sem_init(&sem3,0,0);//初始资源为1,0
 58     //定义线程号变量
 59     pthread_t tid1,tid2,tid3;
 60     if(pthread_create(&tid1,NULL,task1,NULL)!=0)//创建线程分支
 61     {
 62         printf("tid1 create error\n");
 63         return 0;
 64     }
 65     if(pthread_create(&tid2,NULL,task2,NULL)!=0)//无名信号量地址，线程属性，线程体，线程体参数
 66     {
 67         printf("tid2 create error\n");
 68         return 0;
 69     }
 70     if(pthread_create(&tid3,NULL,task3,NULL)!=0)
 71     {
 72         printf("tid3 create error\n");
 73         return 0;
 74     }
 75     printf("tid1:%#lx,tid2:%#lx,tid3:%#lx\n",tid1,tid2,tid3);
 76     //回收线程资源
 77     pthread_join(tid1,NULL);
 78     pthread_join(tid2,NULL);
 79     pthread_join(tid3,NULL);
 80     //释放无名信号量
 81     sem_destroy(&sem1);
 82     sem_destroy(&sem2);
 83     sem_destroy(&sem3);
 84     puts("");
 85     return 0;
 86 }

运行结果：

3.编程实现条件变量

程序代码：

  1 #include<myhead.h>
  2 //1.定义条件变量
  3 pthread_cond_t cond;
  4 //定义互斥锁变量
  5 pthread_mutex_t mutex;
  6 //定义生产线程
  7 void *task1(void *arg)
  8 {
  9     int num=5;
 10     while(num--)
 11     {
 12         sleep(1);
 13         printf("%#lx:生产三蹦子\n",pthread_self());
 14         //3.唤醒一个消费
 15     //  pthread_cond_signal(&cond);//条件变量地址
 16     }
 17     //3.唤醒所以的等待线程
 18     pthread_cond_broadcast(&cond);//条件变量地址
 19     //退出线程
 20     pthread_exit(NULL);
 21 }
 22 //定义消费线程
 23 void *task2(void *arg)
 24 {
 25     //上锁
 26     pthread_mutex_lock(&mutex);
 27     //进入等待队列
 28     pthread_cond_wait(&cond,&mutex);//条件变量指针，互斥锁变量地址
 29     //该函数内部实现
 30     //将当前线程放入休眠等待队列，释放锁资源
 31     //挂起，被其他线程唤醒后：自动获取锁资源
 32     printf("%#lx:消费三蹦子\n",pthread_self());
 33     //解锁
 34     pthread_mutex_unlock(&mutex);
 35     pthread_exit(NULL);
 36 }
 37 int main(int argc, const char *argv[])
 38 {
 39     //2.初始化条件变量
 40     pthread_cond_init(&cond,NULL);//条件变量指针，条件属性
 41     //初始化互斥锁
 42     pthread_mutex_init(&mutex,NULL);//互斥锁变量地址，互斥锁属性
 43     //创建两个线程，生产和消费
 44     pthread_t tid1,tid2,tid3,tid4,tid5,tid6;
 45     if(pthread_create(&tid1,NULL,task1,NULL)!=0)//线程号指针
 46     {
 47         printf("tid1 create error\n");//成0败非0错误码，不是置位错误码
 48         return 0;
 49     }
 50     if(pthread_create(&tid2,NULL,task2,NULL)!=0)//线程属性
 51     {
 52         printf("tid2 create error\n");
 53         return 0;
 54     }
 55     if(pthread_create(&tid3,NULL,task2,NULL)!=0)//线程体，函数指针
 56     {
 57         printf("tid3 create error\n");
 58         return 0;
 59     }
 60     if(pthread_create(&tid4,NULL,task2,NULL)!=0)//线程体的参数
 61     {
 62         printf("tid4 create error\n");
 63         return 0;
 64     }
 65     if(pthread_create(&tid5,NULL,task2,NULL)!=0)
 66     {
 67         printf("tid5 create error\n");
 68         return 0;
 69     }
 70     if(pthread_create(&tid6,NULL,task2,NULL)!=0)
 71     {
 72         printf("tid6 create error\n");
 73         return 0;
 74     }
 75     printf("tid1:%#lx,tid2:%#lx,tid3:%#lx,tid4:%#lx,tid5:%#lx,\
 76             tid6:%#lx\n",tid1,tid2,tid3,tid4,tid5,tid6);
 77     //回收线程资源
 78     pthread_join(tid1,NULL);//线程号，线程回收时状态
 79     pthread_join(tid2,NULL);
 80     pthread_join(tid3,NULL);
 81     pthread_join(tid4,NULL);
 82     pthread_join(tid5,NULL);
 83     pthread_join(tid6,NULL);
 84     //销毁条件变量
 85     pthread_cond_destroy(&cond);//条件变量指针
 86     //销毁互斥锁
 87     pthread_mutex_destroy(&mutex);//无名信号量地址
 88     return 0;
 89 }

运行结果：

4.编程实现无名管道

程序代码：

  1 #include<myhead.h>
  2 int main(int argc, const char *argv[])
  3 {
  4     //创建管道文件，并返回该管道文件的文件描述符
  5     int pipefd[2]={0};//返回pipefd[0]读端，pipefd[1]写端
  6     if(pipe(pipefd)==-1)
  7     {
  8         perror("pipe error");
  9         return -1;
 10     }
 11     printf("pipe[0]=%d,pipe[1]=%d\n",pipefd[0],pipefd[1]);
 12     //创建子进程
 13     pid_t pid=fork();
 14     if(pid>0)
 15     {
 16         //父进程
 17         //关闭管道读端
 18         //创建管道文件放在创建子进程之前，否则各自创建一个管道，无意义
 19         //父进程、子进程都创建同一个管道描述符，
 20         //要关闭父进程的读端，子进程的写端
 21         close(pipefd[0]);//pipefd[0]    读
 22         char wbuf[128]="";
 23         while(1)
 24         {
 25             bzero(wbuf,sizeof(wbuf));//清空数组内容，
 26             //每次写入不同长度，写短了就会保留长的一部分
 27             fgets(wbuf,sizeof(wbuf),stdin);//终端输入数据
 28             wbuf[strlen(wbuf)-1]=0;//把读取的字符串，最后一个改为0，便于比较
 29             //将数据写入管道文件
 30             write(pipefd[1],wbuf,strlen(wbuf));//要操作的文件描述符，容器起始位置，读取大小
 31             //对写入数据判断
 32             if(strcmp(wbuf,"quit")==0)
 33                 break;
 34         }
 35         //关闭写端
 36         close(pipefd[1]);
 37         wait(NULL);//阻塞回收子进程资源
 38     }else if(pid==0)
 39     {
 40         //子进程
 41         //关闭写端
 42         close(pipefd[1]);
 43         char rbuf[128]="";
 44         while(1)
 45         {
 46             //清空rbuf内容
 47             bzero(rbuf,sizeof(rbuf));
 48             //从管道文件中读取数据
 49             read(pipefd[0],rbuf,sizeof(rbuf));
 50             //输出rbuf的数据
 51             printf("父进程传来数据：%s\n",rbuf);
 52             //对读取的数据判断
 53             if(strcmp(rbuf,"quit")==0)
 54                 break;
 55         }
 56         //关闭读端
 57         close(pipefd[0]);
 58         exit(EXIT_SUCCESS);//退出进程
 59     }else
 60     {
 61         perror("fork error");
 62         return -1;
 63     }
 64     return 0;
 65 }

运行结果：

5.编程实现有名管道

程序代码：

create.c：

  1 #include<myhead.h>
  2 int main(int argc, const char *argv[])
  3 {
  4     //创建一个管道文件
  5     if(mkfifo("./myfifo",0664)==-1)
  6     {
  7         perror("mkfifo error");
  8         return -1;
  9     }
 10     getchar();//阻塞
 11     system("rm myfifo");
 12 
 13     return 0;
 14 }

send.c：

  1 #include<myhead.h>
  2 int main(int argc, const char *argv[])
  3 {
  4     //打开管道文件
  5     int wfd=-1;
  6     //以只写形式打开
  7     if((wfd=open("./myfifo",O_WRONLY))=
  8     {
  9         perror("open error");
 10         return -1;
 11     }
 12     //定义容器
 13     char wbuf[128]="";
 14     while(1)
 15     {
 16         printf("请输入>>>");
 17         fgets(wbuf,sizeof(wbuf),stdin);
 18         wbuf[strlen(wbuf)-1]=0;
 19         //将数据写入管道
 20         write(wfd,wbuf,strlen(wbuf));
 21         //判断结果
 22         if(strcmp(wbuf,"quit")==0)
 23             break;
 24     }
 25     //关闭文件
 26     close(wfd);
 27     return 0;
 28 }

rec.c：

  1 #include<myhead.h>
  2 int main(int argc, const char *argv[])
  3 {
  4     //打开管道文件
  5     int rfd=-1;
  6     //以只读形式打开
  7     if((rfd=open("./myfifo",O_RDONLY))=
  8     {
  9         perror("open error");
 10         return -1;
 11     }
 12     //定义容器
 13     char rbuf[128]="";
 14     while(1)
 15     {
 16         //清空数组
 17         bzero(rbuf,sizeof(rbuf));
 18         //读取管道中数据
 19         read(rfd,rbuf,sizeof(rbuf));
 20         //输出结果
 21         printf("收到数据：%s\n",rbuf);
 22         if(strcmp(rbuf,"quit")==0)
 23             break;
 24     }
 25     //关闭文件
 26     close(rfd);
 27     return 0;
 28 }

运行结果：

6.使用有名管道完成两个进程的相互通信

程序代码：

01create：

  1 #include<myhead.h>
  2 int main(int argc, const char *argv[])
  3 {
  4     //创建两个管道文件
  5     if(mkfifo("./myfifo1",0664)==-1)
  6     {
  7         perror("myfifo1 create error");
  8         return -1;
  9     }
 10     if(mkfifo("./myfifo2",0664)==-1)
 11     {
 12         perror("myfifo2 create error");
 13         return -1;
 14     }
 15     printf("create success\n");
 16     getchar();//阻塞进程
 17     system("rm myfifo1 myfifo2");//删除两>
 18     return 0;
 19 }

01send.c：

  1 #include<myhead.h>
  2 int main(int argc, const char *argv[])
  3 {
  4     //两个进程，父进程给管道1写数据，子进程从管道2读取数据
  5     pid_t pid=-1;
  6     pid=fork();
  7     if(pid==0)
  8     {
  9         //子进程管道2读取数据
 10         int rfd=-1;
 11         if((rfd=open("./myfifo2",O_RDONLY))==-1)
 12         {
 13             perror("open myfifo2 error");
 14             return -1;
 15         }
 16         char buf[128]="";
 17         while(1)
 18         {
 19             bzero(buf,sizeof(buf));//清空数组
 20             read(rfd,buf,sizeof(buf));//从管道2读取数据
 21             printf("读取数据：%s\n",buf);
 22             if(strcmp(buf,"quit")==0)
 23                 break;
 24         }
 25         //关闭文件
 26         close(rfd);
 27         //退出进程
 28         exit(EXIT_SUCCESS);
 29     }else if(pid>0)
 30     {
 31         //父进程向管道1写数据
 32         int wfd=-1;
 33         if((wfd=open("./myfifo1",O_WRONLY))==-1)
 34         {
 35             perror("open myfifo1 error");
 36             return -1;
 37         }
 38         char buf[128]="";
 39         while(1)
 40         {
 41             bzero(buf,sizeof(buf));//清空数组
 42             fgets(buf,sizeof(buf),stdin);
 43             buf[strlen(buf)-1]=0;
 44             //将数据写入管道
 45             write(wfd,buf,strlen(buf));
 46             if(strcmp(buf,"quit")==0)
 47                 break;
 48         }
 49         //关闭文件
 50         close(wfd);
 51         //回收子进程资源
 52         wait(NULL);
 53     }else
 54     {
 55         perror("fork error");
 56         return -1;
 57     }
 58     return 0;
 59 }

02send.c：

  1 #include<myhead.h>
  2 int main(int argc, const char *argv[])
  3 {
  4     //两个进程，父进程读取管道1数据，子进程写数据给管道2
  5     pid_t pid=-1;
  6     pid=fork();
  7     if(pid<0)
  8     {
  9         perror("fork error");
 10         return -1;
 11     }else if(pid==0)
 12     {
 13         //子进程写数据给管道2
 14         int wfd=-1;
 15         if((wfd=open("./myfifo2",O_WRONLY))==-1)
 16         {
 17             perror("open myfifo2 error");
 18             return -1;
 19         }
 20         char buf[128]="";
 21         while(1)
 22         {
 23             bzero(buf,sizeof(buf));//清空数组
 24             fgets(buf,sizeof(buf),stdin);
 25             buf[strlen(buf)-1]=0;
 26             //写入数据
 27             write(wfd,buf,strlen(buf));
 28             if(strcmp(buf,"quit")==0)
 29                 break;
 30         }
 31         //关闭文件
 32         close(wfd);
 33         //退出进程
 34         exit(EXIT_SUCCESS);
 35     }else
 36     {
 37         //父进程读取管道1
 38         int rfd=-1;
 39         if((rfd=open("./myfifo1",O_RDONLY))==-1)
 40         {
 41             perror("open myfifo1 error");
 42             return -1;
 43         }
 44         char buf[128]="";
 45         while(1)
 46         {
 47             bzero(buf,sizeof(buf));
 48             //读取数据
 49             read(rfd,buf,sizeof(buf));
 50             printf("读取数据：%s\n",buf);                             
 51             if(strcmp(buf,"quit")==0)
 52                 break;
 53         }
 54         //关闭文件
 55         close(rfd);
 56         wait(NULL);//回收子进程资源
 57     }
 58     return 0;
 59 }

运行结果：