读书人
栏目▼

linux 进程间通信步骤综合分析

发布时间： 2013-10-12 11:54:02 作者： rapoo

linux 进程间通信方法综合分析

进程间通信，常用的方法有，pipe、popen(pclose)、命名pipe、Unix域套接字、消息队列、信号量、记录锁、共享内存。

这么多方法，到底不同方法应用场景是怎样的呢。

1、相关进程(父子进程)

pipe，一定是最简单的，由于子进程可以继承父进程的描述符，所以用2个pipe，就可以实现父子进程间的通信，例子后续给出。

[cpp] view plaincopy
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  5. #define BUF_SIZE 1024
  7. int main()
  8. {
  9. char * str = "Hello world";
  10. char buf[BUF_SIZE] = {0};
  12. int file_pipes[2] = {0};
  14. int pipe_ret = pipe(file_pipes);
  15. if (-1 == pipe_ret)
  16. {
  17. printf("pipe failed\n");
  18. return -1;
  19. }
  21. pid_t fork_ret = fork();
  22. if (-1 == fork_ret)
  23. {
  24. printf("fork failed\n");
  25. return -1;
  26. }
  28. if (0 == fork_ret)
  29. {
  30. close(file_pipes[1]);
  31. int ret_num = read(file_pipes[0], buf, BUF_SIZE);
  32. printf("(%d), read %d bytes: %s\n", getpid(), ret_num, buf);
  33. sleep(1);
  34. return 0;
  35. }
  36. else
  37. {
  38. close(file_pipes[0]);
  39. int ret_num = write(file_pipes[1], str, strlen(str));
  40. printf("(%d), wirte %d bytes: %s\n", getpid(), ret_num, str);
  41. sleep(1);
  42. return 0;
  43. }
  44. return 0;
  46. }
运行结果：
./pipe2
(21653), wirte 11 bytes: Hello world
(21654), read 11 bytes: Hello world

<总结>需要注意的一点就是fork子进程， 子进程会继承父进程pipe(0)、pipe(1)，其只能用一个pipe，所以需要close掉另外一个pipe，通过本例子，可以构造出一个父子进程同步的方法，fork之前pipe两个管道，一个用于父给子发送同步消息，一个用于子给父发送同步消息。

2、进程调用其它进程

输入参数、获取相应输出，用popen(pclose)最划算啦，例如程序用执行ls -l命令，要获取其输出，popen完全ok。下面给出一个简单的例子：

[cpp] view plaincopy
  1. #include <stdio.h>
  2. #include <stdlib.h>
  5. #define BUF_SIZE 1000
  7. int main()
  8. {
  9. FILE * read_fp = NULL;
  10. char buffer[BUF_SIZE] = {0};
  12. read_fp = popen("ls -l", "r");
  13. if (NULL == read_fp)
  14. {
  15. return -1;
  16. }
  18. fread(buffer, 1, BUF_SIZE, read_fp);
  19. printf("out put is \n %s \n", buffer);
  21. pclose(read_fp);
  23. return 0;
  25. }


3、不相干进程

a、如果仅仅用于传递消息，信息量少，Unix域套接字、消息队列都ok，当然是用起来，前者更方便一些，其是用方法和一般的socket方法基本一样；

UNIX域：可以参考我写的另外一个帖子http://blog.csdn.net/beginning1126/article/details/8895738，当中有说明和例子，这里就不赘述了。


b、如果两个进程之前需要共享一大段内存数据，这时再采用Unix域套接字、消息队列就太浪费了，因为两者再传递内存时，都少不了内存的拷贝，共享内存首选，当然用于共享内存的同步，信号量、记录锁都可以，例子后续给出

信号量：可以参考我写的另外一个帖子http://blog.csdn.net/beginning1126/article/details/12520253，当中有说明和例子，这里就不赘述了。


下面给出一个通过信号量做同步，然后用共享内存共享数据的例子：

例子代码比较简陋，功能也比较单一，仅仅用于说明如何通过信号量来达到共享内存的互斥。

进程1：

[cpp] view plaincopy
  1. #include <memory.h>
  2. #include <stdio.h>
  3. #include <unistd.h> //getpagesize( )
  4. #include <sys/ipc.h>
  5. #include <sys/shm.h>
  6. #include <sys/sem.h>
  10. #define MY_SHM_ID 1234
  11. #define MY_SEM_ID 4321
  12. #define MEM_SIZE 300
  14. union semun
  15. {
  16. int val;
  17. struct semid_ds * buf;
  18. unsigned short * array;
  19. };
  21. int semaphore_p(int sem_id) {
  22. struct sembuf sem_b;
  23. sem_b.sem_num = 0;
  24. sem_b.sem_op = -1;
  25. sem_b.sem_flg = SEM_UNDO;
  27. semop(sem_id, &sem_b, 1);
  29. return 0;
  30. }
  32. int semaphore_v(int sem_id) {
  33. struct sembuf sem_b;
  34. sem_b.sem_num = 0;
  35. sem_b.sem_op = 1;
  36. sem_b.sem_flg = SEM_UNDO;
  38. semop(sem_id, &sem_b, 1);
  40. return 0;
  41. }
  44. int set_semvalue(int sem_id) {
  45. union semun sem_union;
  46. sem_union.val = 1;
  48. if (-1 == semctl(sem_id, 0, SETVAL, sem_union))
  49. {
  50. return -1;
  51. }
  52. return 0;
  53. }
  55. int del_semvalue(int sem_id) {
  56. union semun sem_union;
  58. if (-1 == semctl(sem_id, 0, IPC_RMID, sem_union))
  59. {
  60. return -1;
  61. }
  63. return 0;
  64. }
  68. int main() {
  69. printf("page size: %d. \n", getpagesize());
  71. // create share memory
  72. int shmid = 0;
  73. shmid = shmget(MY_SHM_ID, MEM_SIZE, 0666 | IPC_CREAT);
  74. if (-1 == shmid) {
  75. printf("create share memroy failed. \n");
  76. return -1;
  77. }
  78. printf("create a shared memory success, shmid: %d. \n", shmid);
  80. // create sem id
  81. int sem_id = semget((key_t)MY_SEM_ID, 1, 0666 | IPC_CREAT);
  82. set_semvalue(sem_id);
  83. printf("get a sem id: %d\n", sem_id);
  85. // attach share memory
  86. unsigned char * mem = NULL;
  87. mem = shmat(shmid, (const void*)0, 0);
  88. if (-1 == (size_t)mem) {
  89. printf("failed in shmat. \n");
  90. return -1;
  91. }
  92. memset(mem, 0, MEM_SIZE);
  93. printf("attach shm: %p\n", mem);
  95. sleep(5);
  97. // get share memory status
  98. struct shmid_ds shmds;
  99. memset(&shmds, 0, sizeof(struct shmid_ds));
  100. int ret = 0;
  101. ret = shmctl(shmid, IPC_STAT, &shmds);
  102. if (-1 == ret) {
  103. printf("failed in shmctl. \n");
  104. return -1;
  105. }
  106. printf("size of memory segment is %d. \n", shmds.shm_segsz);
  107. printf("numbre of attaches %d. \n", (int)shmds.shm_nattch);
  110. while(1) {
  111. semaphore_p(sem_id);
  112. unsigned char * p = mem;
  113. int len = p[0];
  114. p[len+1] = 'w';
  115. p[0] += 1;
  116. semaphore_v(sem_id);
  117. sleep(1);
  118. if (len >= 254) {
  119. break;
  120. }
  121. }
  123. mem[0] = 'b';
  124. printf("result is %s\n", mem);
  125. del_semvalue(sem_id);
  127. // detach share memory
  128. ret = shmdt(mem);
  129. if(-1 == ret) {
  130. printf("failed in shmdt");
  131. return -1;
  132. }
  134. // delete share memory
  135. ret = shmctl(shmid, IPC_RMID, 0);
  136. if(-1 == ret) {
  137. printf("failded in delete shm. \n");
  138. return -1;
  139. }
  141. return 0;
  142. }

进程2：

[cpp] view plaincopy
  1. #include <memory.h>
  2. #include <stdio.h>
  3. #include <unistd.h> //getpagesize( )
  4. #include <sys/ipc.h>
  5. #include <sys/shm.h>
  6. #include <sys/sem.h>
  8. #define MY_SHM_ID 1234
  9. #define MY_SEM_ID 4321
  10. #define MEM_SIZE 300
  12. union semun
  13. {
  14. int val;
  15. struct semid_ds * buf;
  16. unsigned short * array;
  17. };
  19. int semaphore_p(int sem_id) {
  20. struct sembuf sem_b;
  21. sem_b.sem_num = 0;
  22. sem_b.sem_op = -1;
  23. sem_b.sem_flg = SEM_UNDO;
  25. semop(sem_id, &sem_b, 1);
  27. return 0;
  28. }
  30. int semaphore_v(int sem_id) {
  31. struct sembuf sem_b;
  32. sem_b.sem_num = 0;
  33. sem_b.sem_op = 1;
  34. sem_b.sem_flg = SEM_UNDO;
  36. semop(sem_id, &sem_b, 1);
  38. return 0;
  39. }
  42. int set_semvalue(int sem_id) {
  43. union semun sem_union;
  44. sem_union.val = 1;
  46. if (-1 == semctl(sem_id, 0, SETVAL, sem_union))
  47. {
  48. return -1;
  49. }
  50. return 0;
  51. }
  53. int del_semvalue(int sem_id) {
  54. union semun sem_union;
  56. if (-1 == semctl(sem_id, 0, IPC_RMID, sem_union))
  57. {
  58. return -1;
  59. }
  61. return 0;
  62. }
  66. int main() {
  67. printf("page size: %d. \n", getpagesize());
  69. // create share memory
  70. int shmid = 0;
  71. shmid = shmget(MY_SHM_ID, 0, 0);
  72. if (-1 == shmid) {
  73. printf("get share memroy failed. \n");
  74. return -1;
  75. }
  76. printf("get a shared memory success, shmid: %d. \n", shmid);
  78. // create sem id
  79. int sem_id = semget((key_t)MY_SEM_ID, 1, 0666 | IPC_CREAT);
  80. printf("get a sem id: %d\n", sem_id);
  82. // attach share memory
  83. unsigned char * mem = NULL;
  84. mem = shmat(shmid, (const void*)0, 0);
  85. if (-1 == (size_t)mem) {
  86. printf("failed in shmat. \n");
  87. return -1;
  88. }
  89. printf("attach shm: %p\n", mem);
  93. // get share memory status
  94. struct shmid_ds shmds;
  95. memset(&shmds, 0, sizeof(struct shmid_ds));
  96. int ret = 0;
  97. ret = shmctl(shmid, IPC_STAT, &shmds);
  98. if (-1 == ret) {
  99. printf("failed in shmctl. \n");
  100. return -1;
  101. }
  102. printf("size of memory segment is %d. \n", shmds.shm_segsz);
  103. printf("numbre of attaches %d. \n", (int)shmds.shm_nattch);
  106. while(1) {
  107. semaphore_p(sem_id);
  108. unsigned char * p = mem;
  109. int len = p[0];
  110. p[len+1] = 'r';
  111. p[0] += 1;
  112. semaphore_v(sem_id);
  113. sleep(1);
  114. if (len >= 254) {
  115. break;
  116. }
  117. }
  119. mem[0] = 'b';
  120. printf("result is %s\n", mem);
  122. // detach share memory
  123. ret = shmdt(mem);
  124. if(-1 == ret) {
  125. printf("failed in shmdt");
  126. return -1;
  127. }
  129. return 0;
  130. }

运行结果：

./shm1&

./shm2
page size: 4096.
get a shared memory success, shmid: 1605632.
get a sem id: 1966082
attach shm: 0x2aca081e4000
size of memory segment is 300.
numbre of attaches 2.
result is bwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwrwr

<总结1>：通过运行结果可以看出，w、r，个数相等，同时交替出现，信号量很好的完成对共享内存互斥的工作。当然例子代码很简陋，关于信号量的部分代码有重复，完全可以单独抽出来进行重构，是在懒得改了，看官见谅下吧。

<总结2>：虽然说信号量能够完成对共享内存的互斥，但是这还远远不能满足我们对共享内存同步的要求，比如说，一个写进程，一个读进程，写进程完成对共享内存的写操作之后需要通知读进程来读取内存，当读进程完成读取操作之后，需要通知写进程继续写内容，这种同步操作，如果通过信号量貌似费劲了一点，可以通过UNIX域socket来实现共享内存的同步操作。


c、命名管道，貌似也可以，但是没怎么用过。


<注>很多书中提到STREAMS，由于其不是linux系统默认安装，需要添加附加包，本文章暂不讨论

读书人网 >UNIXLINUX

热点推荐

触屏版 | 电脑版

读书人网 m.reader8.net