进程间通信

最新推荐文章于 2024-11-06 23:59:11 发布

ldlyq

最新推荐文章于 2024-11-06 23:59:11 发布

阅读量38

点赞数

文章标签： c语言

本文链接：https://blog.csdn.net/2301_80969098/article/details/135069346

版权

1.实现AB进程对话。
a.A进程发送一句话后，B进程接收到打印。然后B进程发送一句话，A进程接收后打印b.重复上述步骤。直到AB接收或者发送完quit后，结束AB进程 A.
2．附加题:在上一题的基础上，实现AB进程能够随时收发， 2.附加题:在上一题的基础上，实现AB进程能够随时收发，

B进程

1 #include <stdio.h>
2 #include <errno.h>
3 #include <sys/types.h>
4 #include <unistd.h>
5 #include <sys/stat.h>
6 #include <fcntl.h>
7 #include <string.h>
8 
9 
0 int main(int argc, const char *argv[])
1 {
2 
3     if(mkfifo("./myfifo",0664)<0)//17代表文件已经存在，是一个合法的错误                                                                          
4     {
5       // printf("errno=%d\n", errno);
6         if(errno != 17)
7         {
8             perror("mkfifo");
9             return -1;
0 
1         }
2     }
3     //printf("myfifo create success\n");
4 
5     //printf("open success %d\n ",fd);
6 
7     char buf[128]= "";
8     ssize_t res = 0;
9 
0     //B接收信息
1     while(1)
2     {
3         int fd = open("./myfifo",O_RDONLY);
4         if(fd<0)
5         {
6             perror("fd");
7             return -1;
8 
9     }
0 
1         res = read(fd,buf,sizeof(buf));
2         if(res < 0)
3         {
4             perror("read");
5             return -1;
6 
7         }else if(0 == res)
8         {
9             printf("A进程结束\n");
0             return -1;
1 
2         }
3 
4         printf("A说：%s\n",buf);
5 
6 
7         close(fd);
8 
9 
0     /*
1         if(strcmp(buf,"quit")== 0)
2         {
3             break;
4 
5         }
6         */
7 
8 
9 
0 
1 
2     //B发送信息写
3 
4      fd = open("./myfifo",O_WRONLY);
5         fgets(buf,sizeof(buf),stdin);
6         buf[strlen(buf)]='\0';
7         if(write(fd,buf,sizeof(buf))<0)
8         {
9             perror("write");
0             return -1;
1 
2         }
3         printf("B发送成功\n");
4 
5 
6 
7         if(strcmp(buf,"quit")== 0)
8         {
9             break;
0 
1         }
2 
3 
4     close(fd);
5 
6     }
7 
8 
9     return 0;
0 }

A进程

 #include <stdio.h>
 #include <errno.h>
 #include <sys/types.h>
 #include <unistd.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <string.h>
 
 
 
 int main(int argc, const char *argv[])
 {
 
     if(mkfifo("./myfifo",0664)<0)//17代表文件已经存在，是一个合法的错误
     {
        //printf("errno=%d\n", errno);
         if(errno != 17)
         {
             perror("mkfifo");
             return -1;
 
         }
     }
     //printf("myfifo create success\n");
     //printf("open success %d\n ",fd);
 
 
     char buf[128]="";
     int res=0;
 
     //A发送信息写
     while(1)
     {
 
     int fd = open("./myfifo",O_WRONLY);
     if(fd<0)
     {
         perror("fd");
         return -1;                                                                                                                      
 
     }
 
         fgets(buf,sizeof(buf),stdin);
         buf[strlen(buf)]='\0';
 
         if(write(fd,buf,sizeof(buf))<0)
         {
             perror("write");
             return -1;
         }
 
         printf("A发送成功\n");
 
         /*
         if(strcmp(buf,"quit") == 0)
         {
             break;
 
         }
         */
         close(fd);
 
 
 
 
 
     //A接受信息（读）
      fd = open("./myfifo",O_RDONLY);
         res = read(fd,buf,sizeof(buf));
         if(res<0)
         {
             perror("read");
             return -1;
 
         }else if(0==res)
         {
             printf("B进程结束\n");
             return -1;
 
         }
         printf("B说：%s\n",buf);
 
 
         if(strcmp(buf,"quit") == 0)
         {
             break;
         }
 
 
     close(fd);
     }
 
 
     return 0;
 }

1.有三个线程，ID号分别为ABC，且每个线程中都在循环打印自己的ID。要求打印的结果为ABC。

 1 #include <myhead.h>
 2 
 3 //定义互斥锁
 4 pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
 5 
 6 //定义条件变量
 7 pthread_cond_t cond0 = PTHREAD_COND_INITIALIZER;
 8 pthread_cond_t cond1 = PTHREAD_COND_INITIALIZER;
 9 pthread_cond_t cond2 = PTHREAD_COND_INITIALIZER;
10 
11 
12 int flag = 0;//0:A,1:B,2:C 
13 
14 void* callbackA(void* arg)
15 {
16 
17     while(1)
18     {
19         //上锁
20         pthread_mutex_lock(&mutex);
21         //让线程进入休眠阻塞状态，等待特定条件唤醒
22         if(flag != 0)
23         {
24             //解锁，设置条件变量，进入休眠等待唤醒
25             pthread_cond_wait(&cond0,&mutex);
26             //收到唤醒信号后，会在短时间内尝试上锁
27             //上锁成功继续在当前位置往后执行后续代码
28             //上锁失败，重新回到cond休眠，
29 
30         }
31         printf("A");
32         flag = 1;
33         //唤醒线程
34         pthread_cond_signal(&cond1);
35         //解锁
36         pthread_mutex_unlock(&mutex);
37 
38     }
39     pthread_exit(NULL);
40 
41 
42 }
43 
44 void* callbackB(void* arg)
45 {
46     while(1)
47     {
48         //上锁
49         pthread_mutex_lock(&mutex);
50         if(flag != 1)
51         {
52             //解锁，设置条件变量，进入休眠等待唤醒
53             pthread_cond_wait(&cond1,&mutex);
54             //收到唤醒信号后，会在短时间内尝试上锁
55             //上锁成功继续在当前位置往后执行后续代码
56             //上锁失败，重新回到cond休眠，
57 
58         }
59 
60         printf("B");
61         flag = 2;
62         //唤醒线程
63         pthread_cond_signal(&cond2);
64         //解锁
65         pthread_mutex_unlock(&mutex);
66     }
67     pthread_exit(NULL);
68 }
69 void* callbackC(void* arg)
70 {
71     while(1)
72     {
73         //上锁
74         pthread_mutex_lock(&mutex);
75         if(flag != 2)
76         {
77             //解锁，设置条件变量，进入休眠等待唤醒
78             pthread_cond_wait(&cond2,&mutex);
79             //收到唤醒信号后，会在短时间内尝试上锁
80             //上锁成功继续在当前位置往后执行后续代码
81             //上锁失败，重新回到cond休眠，
82 
83         }
84 
85         printf("C\n");
86         flag = 0;
87         //唤醒线程
88         pthread_cond_signal(&cond0);
89         //解锁
90         pthread_mutex_unlock(&mutex);
91     }
92     pthread_exit(NULL);
93 }
94 
95 int main(int argc, const char *argv[])
96 {
97     //创建互斥锁
98     //pthread_mutex_init(&mutex,NULL);
99 
00 
01     pthread_t tid1;
02     pthread_t tid2;
03     pthread_t tid3;
04     pthread_create(&tid1,NULL,callbackA,NULL);//可以通过NULL传参，不用全局
05     pthread_create(&tid2,NULL,callbackB,NULL);
06     pthread_create(&tid3,NULL,callbackC,NULL);
07 
08 
09 
10     pthread_join(tid1,NULL);
11     pthread_join(tid2,NULL);
12     pthread_join(tid3,NULL);
13 
14 
15 
16     //销毁互斥锁
17     pthread_mutex_destroy(&mutex);
18     pthread_cond_destroy(&cond0);
19     pthread_cond_destroy(&cond1);
20     pthread_cond_destroy(&cond2);
21     return 0;
22 }