devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Linux进程间通信_linux进程通信

作者：2023面试高手 | 2024-05-12 18:40:55

赞

踩

linux进程通信

目录

进程间通信的目的

进程间通信的几种方式

无名管道

命名管道

创建键值函数ftok()

消息队列

创建或引用一个消息队列msgget()

向消息队列中添加消息msgsnd()

从消息队列中读取消息msgrcv()

控制消息队列msgctl()

共享内存

创建或引用一个共享内存shmget()

将共享内存链接到当前进程的地址空间shmat()

断开共享内存与当前进程的地址空间的链接shmdt()

控制共享内存shmc

管道、消息队列、共享内存的区别

信号

向某个进程发送信号函数kill()

信号接收函数signal()

高级信号发送函数sigqueue(),比kill()在发射信号时能携带更多信息

高级信号接收函数sigaction()，比signal()在接收信号时能获取更多信息

信号量

 创建一个信号量集semget()

控制信号量集或获取信号量的信息semctl()

信号量控制共享资源的操作，即PV操作semop()

进程间通信的目的

  • 数据传输:一个进程需要将它的数据发送给另一个进程
  • 资源共享:多个进程之间共享同样的资源
  • 通知事件:一个进程需要向另一个或一组进程发送消息，通知它发生了某种事件。
  • 进程控制:有些进程希望完全控制另一个进程的执行(如 Debug进程)，此时控制进程希望能够拦截另 一个进程的所有陷入和异常，并能够及时知道它的状态改变

进程间通信的几种方式

无名管道

  1. #include <stdio.h>
  2. #include <sys/types.h>
  3. #include <unistd.h>
  4. #include <stdlib.h>
  5. #include <sys/wait.h>
  6.  
  7. int main()
  8. {
  9.     pid_t pid;
  10.     int fd[2];
  11.     char readBuf[128];
  12.  
  13.     if(pipe(fd) < 0){
  14.         perror("pipe");
  15.         exit(-1);
  16.     }
  17.  
  18.     pid = vfork();
  19.  
  20.     if(pid == 0){
  21.         printf("this is child process\n");
  22.         close(fd[0]);
  23.         write(fd[1],"my name is child process,haozige handsome",128);
  24.         printf("child process is done\n");
  25.         exit(0);
  26.     
  27.     }else if(pid > 0){
  28.         printf("this is father process\n");
  29.         wait(NULL);
  30.         close(fd[1]);
  31.         read(fd[0],readBuf,128);
  32.         printf("from child process content is %s\n",readBuf);
  33.         printf("father process is done\n");
  34.  
  35.     }else{
  36.         printf("fork is fail\n");
  37.         perror("fork");
  38.         exit(-1);
  39.     }
  40.  
  41.     return 0;
  42. }

命名管道

与无名管道不同的是，命名管道可以在没有关系的两个进程间进行通信

由于read()函数在读不到数据时会阻塞，因此我们在读数据的进程创建命名管道，并阻塞等待写数据的进程向命名管道写入数据 ，在创建命名管道时，给管道的权限建议是0600，即可读可写可执行

读数据进程

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <sys/types.h>
  4. #include <sys/stat.h>
  5. #include <fcntl.h>
  6. #include <unistd.h>
  7. #include <string.h>
  8.  
  9. int main(int argc,char *argv[])
  10. {
  11.     if(argc < 2){
  12.         printf("missing paramiter -> FIFO");
  13.         exit(-1);
  14.     }
  15.  
  16.     char readBuf[128];
  17.     int readSize = 0;
  18.  
  19.     if(mkfifo(argv[1],0600) < 0){
  20.         perror("mkfifo");
  21.         exit(-1);
  22.     }
  23.  
  24.     int fd = open(argv[1],O_RDONLY);
  25.     if(fd < 0){
  26.         perror("open");
  27.         exit(-1);
  28.     }
  29.  
  30.     while(1){
  31.         memset(readBuf,'\0',128);
  32.         readSize = read(fd,readBuf,128);
  33.         printf("read data from FIFO %s, content is %s\n",argv[1],readBuf);
  34.     }
  35.     close(fd);
  36.  
  37.     return 0;
  38. }

命名管道是类似创建文件的形式创建的  

写数据进程

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <sys/types.h>
  4. #include <sys/stat.h>
  5. #include <fcntl.h>
  6. #include <unistd.h>
  7. #include <string.h>
  8.  
  9. int main(int argc,char *argv[])
  10. {
  11.     if(argc < 2){
  12.         printf("missing paramiter -> FIFO");
  13.         exit(-1);
  14.     }
  15.  
  16.     char Msg[128] = "from write FIFO send jiangxiaoya is pigHead";
  17.  
  18.     int fd = open(argv[1],O_WRONLY);
  19.  
  20.     while(1){
  21.         write(fd,Msg,strlen(Msg));
  22.         sleep(1);
  23.     }
  24.     close(fd);
  25.  
  26.     return 0;
  27. }

 当写数据进程启动后，读数据进程不再阻塞，开始读取命名管道的数据

命名管道的应用：

  • shell命令使用FIFO将数据从一条管道传送到另一条时，无需创建中间临时文件。
  • 客户进程-服务器进程应用程中，FIFO用作汇聚点，在客户进程和服务器进程二者之间传递数据。

创建键值函数ftok()

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <sys/types.h>
  4. #include <sys/ipc.h>
  5.  
  6. int main(int argc,char *argv[])
  7. {
  8.     if(argc < 2){
  9.         printf("missing parameter -> keyfile\n");
  10.         exit(-1);
  11.     }
  12.     key_t key;
  13.     key = ftok(argv[1],'z');
  14.  
  15.     if(key == -1){
  16.         perror("ftok");
  17.         exit(-1);
  18.     }else{
  19.         printf("key value is %d\n",key);
  20.     }
  21.  
  22.     key = ftok(argv[1],159);
  23.  
  24.     if(key == -1){
  25.         perror("ftok");
  26.         exit(-1);
  27.     }else{
  28.         printf("key value is %d\n",key);
  29.     }
  30.  
  31.     return 0;
  32. }

消息队列

消息队列是一个存储信息的链表，全双工通信，进程终止后，数据不会丢式 

创建或引用一个消息队列msgget()

向消息队列中添加消息msgsnd()

从消息队列中读取消息msgrcv()

控制消息队列msgctl()

 

 向消息队列添加各种消息的sendMsg进程

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <sys/types.h>
  4. #include <sys/ipc.h>
  5. #include <sys/msg.h>
  6. #include <string.h>
  7.  
  8. struct Msgbuf
  9. {
  10.     long mtype;
  11.     char mtext[128];
  12. };
  13.  
  14. int main(int argc,char *argv[])
  15. {
  16.     key_t key;
  17.     key = ftok("./keyfile.txt",'z');
  18.  
  19.     if(key == -1){
  20.         perror("ftok");
  21.         exit(-1);
  22.     }
  23.  
  24.     int msgID = msgget(key,IPC_CREAT|0777);
  25.  
  26.     if(msgID == -1){
  27.         perror("msgget");
  28.         exit(-1);
  29.     }
  30.  
  31.     struct Msgbuf sendMsg = {
  32.         130,
  33.         "this is sendMsg process"
  34.     };
  35.  
  36.     struct Msgbuf sendMsg1 = {
  37.         181,
  38.         "haozige handsome"
  39.     };
  40.  
  41.     struct Msgbuf sendMsg2 = {
  42.         166,
  43.         "jiangxiaoya pigHand"
  44.     };
  45.  
  46. 	msgsnd(msgID,&sendMsg,strlen(sendMsg.mtext),0);
  47.     msgsnd(msgID,&sendMsg1,strlen(sendMsg1.mtext),0);
  48.     msgsnd(msgID,&sendMsg2,strlen(sendMsg2.mtext),0);
  49.  
  50.     struct Msgbuf receive;
  51.     memset(&receive,0,sizeof(receive));
  52.     msgrcv(msgID,&receive,sizeof(receive.mtext),2349,0);
  53.  
  54.     printf("this is sendMsg process,receive msg from messageQueue,content is %s\n",receive.mtext);
  55.  
  56.     //msgctl(msgID,IPC_RMID,NULL);
  57.  
  58.     return 0;
  59. }

根据消息字段读取消息队列中的消息的receive进程，要使用同一个键值才能访问到同一个消息队列 

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <sys/types.h>
  4. #include <sys/ipc.h>
  5. #include <sys/msg.h>
  6. #include <string.h>
  7. #include <unistd.h>
  8.  
  9. struct Msgbuf
  10. {
  11.     long mtype;
  12.     char mtext[128];
  13. };
  14.  
  15. int main(int argc,char *argv[])
  16. {
  17.     key_t key;
  18.     key = ftok("./keyfile.txt",'z');
  19.  
  20.     if(key == -1){
  21.         perror("ftok");
  22.         exit(-1);
  23.     }
  24.  
  25.     int msgID = msgget(key,IPC_CREAT|0777);
  26.  
  27.     if(msgID == -1){
  28.         perror("msgget");
  29.         exit(-1);
  30.     }
  31.  
  32.     struct Msgbuf sendMsg = {
  33.         2349,
  34.         "this is receiveMsg process"
  35.     };
  36.  
  37.     msgsnd(msgID,&sendMsg,strlen(sendMsg.mtext),0);
  38.  
  39.     struct Msgbuf receive;
  40.     struct Msgbuf receive1;
  41.     struct Msgbuf receive2;
  42. 	memset(&receive,0,sizeof(receive));
  43.     memset(&receive1,0,sizeof(receive1));
  44.     memset(&receive2,0,sizeof(receive2));
  45.  
  46.     msgrcv(msgID,&receive,sizeof(receive.mtext),130,0);
  47.     msgrcv(msgID,&receive1,sizeof(receive1.mtext),181,0);
  48.     msgrcv(msgID,&receive2,sizeof(receive2.mtext),166,0);
  49.  
  50.     printf("this is receiveMsg process,receive msg from messageQueue,content is %s\n",receive.mtext);
  51.     sleep(5);
  52.     printf("this is receiveMsg process,receive msg from messageQueue,content is %s\n",receive1.mtext);
  53.     sleep(5);
  54.     printf("this is receiveMsg process,receive msg from messageQueue,content is %s\n",receive2.mtext);
  55.  
  56.     msgctl(msgID,IPC_RMID,NULL);
  57.  
  58.     return 0;
  59. }

 

共享内存

创建或引用一个共享内存shmget()

将共享内存链接到当前进程的地址空间shmat()

断开共享内存与当前进程的地址空间的链接shmdt()

控制共享内存shmctl

 创建一块共享内存，writeShm进程每隔1秒向共享内存写入一个字母，readShm进程每隔一秒从共享内存读取一个字母，当从共享内存连续10s读不到数据后，会删除该共享内存

my_writeShm进程：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <sys/types.h>
  4. #include <sys/ipc.h>
  5. #include <unistd.h>
  6. #include <string.h>
  7. #include <sys/shm.h>
  8.  
  9.  
  10. int main(int argc,char *argv[])
  11. {
  12.     key_t key = ftok(".",'z');
  13.  
  14.     if(key == -1){
  15.         perror("ftok");
  16.         exit(-1);
  17.     }
  18.  
  19.     int shmID = shmget(key,1024*4,IPC_CREAT|0666);
  20.  
  21.     if(shmID == -1){
  22.         perror("shmget");
  23.         exit(-1);
  24.     }
  25.  
  26.     char *tmp = (char *)shmat(shmID,NULL,0);
  27.     memset(tmp,'\0',1024*4);
  28.     char *str = "abcdefghijklmnopqrstuvwxyz";
  29.  
  30.     while(*str != '\0'){
  31.         sprintf(tmp,"%c",*str);
  32.         sleep(1);
  33.         *str++;
  34.     }
  35.     memset(tmp,'\0',1024*4);
  36.  
  37.     shmdt(tmp);
  38.  
  39.     //shmctl(shmID,IPC_RMID,NULL);
  40.  
  41.     return 0;
  42. }

my_readShm进程： 

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <sys/types.h>
  4. #include <sys/ipc.h>
  5. #include <unistd.h>
  6. #include <string.h>
  7. #include <sys/shm.h>
  8.  
  9.  
  10. int main(int argc,char *argv[])
  11. {
  12.     key_t key = ftok(".",'z');
  13.  
  14.     if(key == -1){
  15.         perror("ftok");
  16.         exit(-1);
  17.     }
  18.  
  19.     int shmID = shmget(key,1024*4,IPC_CREAT|0666);
  20.  
  21.     if(shmID == -1){
  22.         perror("shmget");
  23.         exit(-1);
  24.     }
  25.  
  26.     char *tmp = (char *)shmat(shmID,NULL,0);
  27.     while(1){
  28.         printf("shm content is %s\n",tmp);
  29.         sleep(1);
  30.  
  31.         if(strlen(tmp) == 0){
  32.             sleep(10);
  33.             if(strlen(tmp) == 0){
  34.                 break;
  35.             }
  36.         }
  37.     }
  38.     shmdt(tmp);
  39.  
  40.     shmctl(shmID,IPC_RMID,NULL);
  41.  
  42.     return 0;
  43. }

管道、消息队列、共享内存的区别

将三者进程间的通信看作纸条上的通信

  • 管道：一方拿走这个纸条进行写内容，另一方只能等对方写完这个纸条才能拿走这个纸条进行读内容，半双工通信
  • 消息队列：在一个纸箱存放着多张纸条，纸条上有号码标注，每一张纸条都是独一无二，一方拿走了一张纸条进行写内容或读内容，同时另一方也拿走了一张纸条进行写内容或读内容，操作完后会把纸条放回纸箱中，全双工通信
  • 共享内存：双方同时拿着纸条，一方在纸条写内容，另一方实时在纸条上读内容（实时性）

信号

向某个进程发送信号函数kill()

信号接收函数signal()

使用signal()函数实现Linux定时器，每隔2s输出一个字符串，使用kill()关闭这个定时器

signal()进程

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <sys/time.h>
  5. #include <signal.h>
  6.  
  7. static int i = 0;
  8.  
  9. void time_handle(int signum)
  10. {
  11.     i++;
  12.     if(i == 2000){
  13.         printf("2s to hello haozige,my process pid is %d\n",getpid());
  14.         i = 0;
  15.     }
  16. }
  17.  
  18. int main()
  19. {
  20.  
  21.     struct itimerval tmp;
  22.  
  23.     tmp.it_value.tv_sec = 0;
  24.     tmp.it_value.tv_usec = 500*1000;
  25.  
  26.     tmp.it_interval.tv_sec = 0;
  27.     tmp.it_interval.tv_usec = 500;
  28.  
  29.     if(setitimer(ITIMER_REAL,&tmp,NULL) == -1){
  30.         perror("setitimer");
  31.         exit(-1);
  32.     }//SIGALRM
  33.  
  34.     signal(SIGALRM,time_handle);
  35.     while(1);
  36.     return 0;
  37. }

相关结构体

 

 

 kill()进程

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <sys/types.h>
  5. #include <signal.h>
  6.  
  7.  
  8. int main(int argc,char *argv[])
  9. {
  10.     if(argc < 2){
  11.         printf("missing parameter -> process pid\n");
  12.         exit(-1);
  13.     }
  14.  
  15.     pid_t pid = atoi(argv[1]);
  16.  
  17.     kill(pid,SIGINT);
  18.     sleep(1);
  19.     printf("pid is %d process is done!\n",pid);
  20.     return 0;
  21. }

高级信号发送函数sigqueue(),比kill()在发射信号时能携带更多信息

 

高级信号接收函数sigaction()，比signal()在接收信号时能获取更多信息

sigset_t sa_mask:

 int sa_flags:

 siginfo_t 结构：保存的其他信息

进程A使用sigqueue向进程B发送信号和携带信息：年龄21和年龄20两个整型数，进程B收到该信号后进行处理

进程A：sigqueue()

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <sys/types.h>
  5. #include <signal.h>
  6.  
  7. int main(int argc,char *argv[])
  8. {
  9.     if(argc < 2){
  10.         printf("missing parameter -> process pid\n");
  11.         exit(-1);
  12.     }
  13.  
  14.     pid_t pid = atoi(argv[1]);
  15.  
  16.     int tmp = 0;
  17.     union sigval msg;
  18.     msg.sival_int = 21;
  19.  
  20.     while(1){
  21.         sigqueue(pid,SIGUSR1,msg);
  22.         tmp++;
  23.         if(tmp == 5){
  24.             msg.sival_int = 19;
  25.         }
  26.         if(tmp == 10){
  27.             kill(pid,SIGINT);
  28.             break;
  29.         }
  30.         sleep(1);
  31.     }
  32.     return 0;
  33. }

进程B：sigaction() 

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <sys/time.h>
  5. #include <signal.h>
  6.  
  7. static int i = 0;
  8.  
  9. void time_handle(int signum,siginfo_t *tmp,void *context)
  10. {
  11.  
  12.     if(context != NULL){
  13.         printf("msg from pid %d process\n",tmp->si_pid);
  14.         printf("age is %d\n",tmp->si_value.sival_int);
  15.         printf("age is %d\n",tmp->si_int);
  16.     }else{
  17.         printf("Segment errors may occur\n");
  18.         printf("1%s",(char *)context);
  19.     }
  20. }
  21.  
  22. int main()
  23. {
  24.     struct sigaction sigMsg;
  25.     printf("my process pid is %d\n",getpid());
  26.  
  27.     sigMsg.sa_flags = SA_SIGINFO;
  28.     sigMsg.sa_sigaction = time_handle;
  29.  
  30.     sigemptyset(&sigMsg.sa_mask);//初始化信号集，清空该信号集里的所有信号
  31.  
  32.     sigaction(SIGUSR1,&sigMsg,NULL);
  33.  
  34.     while(1);
  35.     return 0;
  36. }

信号量

 信号量并非单个非负值，必须定义为多个信号量的集合，称为信号量集

 创建一个信号量集semget()

控制信号量集或获取信号量的信息semctl()

 

 

信号量控制共享资源的操作，即PV操作semop()

 

 信号量保证子进程先运行，父进程后运行，同理子进程先获得临界资源，父进程后获得临界资源

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <sys/types.h>
  4. #include <sys/ipc.h>
  5. #include <sys/ipc.h>
  6. #include <sys/sem.h>
  7. #include <unistd.h>
  8.  
  9. //semctl()参数4,保存信号量的信息或者设置信号量的信息
  10. union semun {
  11.     int val;    
  12.     struct semid_ds *buf;    
  13.     unsigned short  *array;  
  14.     struct seminfo  *__buf;  
  15. };
  16.  
  17. //p操作
  18. void handle_P(int id)
  19. {
  20.     struct sembuf pBuf;
  21.     pBuf.sem_num = 0;
  22.     pBuf.sem_op = -1;
  23.     pBuf.sem_flg = SEM_UNDO;
  24.     if(semop(id,&pBuf,1) < 0){
  25.         perror("semop");
  26.         exit(-1);
  27.     }
  28. }
  29.  
  30. //v操作
  31. void handle_V(int id)
  32. {
  33.     struct sembuf vBuf;
  34.     vBuf.sem_num = 0;
  35.     vBuf.sem_op = 1;
  36.     vBuf.sem_flg = SEM_UNDO;
  37.     if(semop(id,&vBuf,1) < 0){
  38.         perror("semop");
  39.         exit(-1);
  40.     }
  41. }
  42.  
  43. int main(int argc,char *argv[])
  44. {
  45.     key_t key = ftok(".",'z');
  46.  
  47.     if(key == -1){
  48.         perror("ftok");
  49.         exit(-1);
  50.     }
  51.  
  52.     int semID = semget(key,1,IPC_CREAT|0666);
  53.  
  54.     if(semID < 0){
  55.         perror("semget");
  56.         exit(-1);
  57.     }
  58.  
  59.     union semun tmp;
  60.     tmp.val = 0; //信号量初始值
  61.  
  62.     if(semctl(semID,0,SETVAL,tmp) < 0){
  63.         perror("semctl");
  64.         exit(-1);
  65.     }
  66.     pid_t pid = fork();
  67.     if(pid > 0){
  68. 		//如果父进程先运行，由于信号量初始值为0，执行p操作后父进程进入阻塞状态
  69.         printf("father process is wait\n");
  70.         handle_P(semID);//p操作
  71.         printf("child process lets father process cancel wait\n");
  72.  
  73.         semctl(semID,0,IPC_RMID);
  74.  
  75.     }else if(pid == 0){
  76. 		//子进程运行
  77.         printf("child process function\n");
  78. 		//5s后执行v操作唤醒父进程
  79.         printf("wake up the father process after 5s\n");
  80.         int i;
  81.         for(i=1;i<6;i++){
  82.             sleep(1);
  83.             printf("%d\n",i);
  84.         }
  85.         handle_V(semID);//v操作
  86.    
  87.    }else{
  88.         perror("fork");
  89.         exit(-1);
  90.     }
  91.  
  92.     return 0;
  93. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/560220
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号