进程间的通信

644725825

当程序运行时，父进程 fork 出 4 个子进程。父进程负责产生消息（每 1s 产生一个消息）， 4 个子进程负责处理消息。父子进程之间通过消息队列来传递消息。
父进程需要维护一个本地数据库（格式与共享数据库相同），当生成一个消息时，父进程要同步更新本地数据库。子进程在处理消息时，根据消息的内容来对共享数据库进行更新（比如，当一个子进程收到一个[index=2, op=increase]的消息时，需要将共享数据库中 index 为 2 的条目的 count 值递增 1 ），并延迟 500ms 。
父进程需要处理 SIGTERM 信号。父进程接收到 SIGTERM 信号意味着要求结束该程序。在结束程序之前，父进程要结束所有子进程、显示并对比本地数据库和共享数据库中的信息（两者应该相同）。

Krant5

有点意思，好好写

json

看了一下题意，不是特别理解（估计是我个人问题，哈哈）。写了一个demo，还有许多问题，暂时先抛砖引玉啦~

1. #include <unistd.h>
   
2. #include <stdlib.h>
   
3. #include <stdio.h>
   
4. #include <sys/types.h>
   
5. #include <sys/msg.h>
   
6. #include <sys/ipc.h>
   
7. #include <sys/shm.h>
   
8. #include <signal.h>
   
9. #include <string.h>
   
10. 
    
11. #define OPT_INCR 0
    
12. #define OPT_INCRBY 1
    
13. #define OPT_DECR 2
    
14. #define OPT_DECRBY 3
    
15. 
    
16. #define DB_SIZE 10
    
17. #define CHILD_COUNT 4
    
18. 
    
19. int msgid = 1;
    
20. int main_running = 1;
    
21. int sub_running = 1;
    
22. int pids[CHILD_COUNT];
    
23. struct msg_t {
    
24.    int opt;
    
25.    int index;
    
26.    int data;
    
27. };
    
28. 
    
29. void opt_handler(int * db, struct msg_t * msg) {
    
30.    switch (msg->opt) {
    
31.    case OPT_INCR:
    
32.       db[msg->index] ++;
    
33.       break;
    
34.    case OPT_INCRBY:
    
35.       db[msg->index] += msg->data;
    
36.       break;
    
37.    case OPT_DECR:
    
38.       db[msg->index] --;
    
39.       break;
    
40.    case OPT_DECRBY:
    
41.       db[msg->index] -= msg->data;
    
42.       break;
    
43.    deafult:
    
44.       printf("Not support opt: %d\n", msg->opt);   
    
45.    }
    
46. }
    
47. 
    
48. 
    
49. void child_process(int * shm_db, int msgid) {
    
50.    struct msg_t msg;
    
51.    struct msqid_ds msg_info;
    
52.    while (1) {
    
53.       sleep(0.5);
    
54.       msgctl(msgid, IPC_STAT, &msg_info);
    
55.       if (msg_info.msg_qnum <= 0) {
    
56.          //sleep(CHILD_COUNT);
    
57.          if (!sub_running) break;
    
58.          continue;
    
59.       }
    
60.       if (msgrcv(msgid, (struct msg_t *)&msg, sizeof(&msg), 0, 0) == -1) {
    
61.          fprintf(stderr, "subpid[%d]: msgcrv failed\n", getpid());
    
62.          continue;
    
63.       }
    
64.       printf("GET[%d]: %d, %d, %d\n", getpid(), msg.opt, msg.index, msg.data);
    
65.       opt_handler(shm_db, &msg);
    
66.    }
    
67.    exit(EXIT_SUCCESS);
    
68. }
    
69. 
    
70. void show_db(int * db, int * shm_db) {
    
71.    int i;
    
72.    printf("index\tlocal val\tshm val\n");
    
73.    for (i = 0; i < DB_SIZE; i++) {
    
74.       printf("%d\t%d\t\t%d\n", i, db[i], shm_db[i]);
    
75.    }
    
76. }
    
77. 
    
78. void sub_usr1_handler() {
    
79.    sub_running = 0;
    
80. }
    
81. 
    
82. void term_handler() {
    
83.    printf("I got SIGTERM...\n");
    
84.    main_running = 0;
    
85.    int i;
    
86.    for (i = 0; i < CHILD_COUNT; i++) {
    
87.       kill(pids[i], SIGUSR1);
    
88.    }
    
89. }
    
90. 
    
91. 
    
92. int main() {
    
93.    int db[DB_SIZE], *shm_db, i, status=0, wpid;
    
94.    key_t mapKey = (key_t)1234, msgKey = (key_t)4321;
    
95.    struct msg_t msg;
    
96.    
    
97.    char *pidfile = "tmp.pid";
    
98.    int pid = getpid();
    
99.    char pid_s[8];
    
100.    sprintf(pid_s, "%d", pid);
     
101.    FILE * fp = fopen(pidfile, "w");
     
102.    if (fp == NULL) {
     
103.       fprintf(stderr, "open %s file failed.\n", pidfile);
     
104.       exit(EXIT_FAILURE);
     
105.    }
     
106.    fwrite(pid_s, sizeof(pid_s), 1, fp);
     
107.    fclose(fp);
     
108. 
     
109.    srand((unsigned)time(NULL));
     
110. 
     
111.    msgid = msgget(msgKey, 0666 | IPC_CREAT);
     
112.    if (msgid == -1) {
     
113.       fprintf(stderr, "msgget error.\n");
     
114.       exit(EXIT_FAILURE);
     
115.    }
     
116. 
     
117.    int shmid = shmget(mapKey, sizeof(db), IPC_CREAT);
     
118.    if (shmid == -1) {
     
119.       fprintf(stderr, "shmget error.\n");
     
120.       exit(EXIT_FAILURE);
     
121.    }
     
122.    
     
123.    shm_db = (int *)shmat(shmid, NULL, 0);
     
124.    
     
125.    memset(db, 0, sizeof(db));
     
126.    memset(shm_db, 0, sizeof(db));
     
127. 
     
128.    struct sigaction subsig;
     
129.    subsig.sa_handler = sub_usr1_handler;
     
130.    sigemptyset(&subsig.sa_mask);
     
131.    subsig.sa_flags = SA_RESETHAND;
     
132.    sigaction(SIGUSR1, &subsig, 0);
     
133. 
     
134.    for (i = 0; i < CHILD_COUNT; i++) {
     
135.       if ((pids[i] =fork()) == 0) {
     
136.          child_process(shm_db, msgid);
     
137.       }
     
138.    }
     
139. 
     
140.    struct sigaction sig;
     
141.    sig.sa_handler = term_handler;
     
142.    sigemptyset(&sig.sa_mask);
     
143.    sig.sa_flags = SA_RESETHAND;
     
144.    sigaction(SIGTERM, &sig, 0);
     
145. 
     
146.    show_db(db, shm_db);
     
147. 
     
148.    while (main_running) {
     
149.       msg.opt = rand()%4;
     
150.       msg.index = rand()%8 + 1;
     
151.       msg.data = rand()%10 + 1;
     
152.       printf("POST[%d]: %d, %d, %d\n", getpid(), msg.opt, msg.index, msg.data);
     
153.       if (msgsnd(msgid, &msg, sizeof(&msg), 0) == -1) {
     
154.          fprintf(stderr, "msgsnd failed\n");
     
155.          continue;
     
156.       }
     
157.       opt_handler(db, &msg);
     
158.       sleep(1);
     
159.    }
     
160. 
     
161.    while( (wpid = wait(&status)) > 0) {
     
162.       printf("subproc[%d] exit.\n", wpid);
     
163.    }
     
164.    
     
165.    show_db(db, shm_db);
     
166. 
     
167.    if (msgctl(msgid, IPC_RMID, 0) == -1) {
     
168.       fprintf(stderr, "msgctl error.\n");
     
169.       exit(EXIT_FAILURE);
     
170.    }
     
171. 
     
172.    if (shmdt(shm_db) == -1) {
     
173.       fprintf(stderr, "shm detach error\n");
     
174.       exit(EXIT_FAILURE);
     
175.    }
     
176. 
     
177.    if (shmctl(shmid, IPC_RMID, 0) == -1) {
     
178.       fprintf(stderr, "shm remove failed.\n");
     
179.       exit(EXIT_FAILURE);
     
180.    }
     
181. 
     
182.    exit(EXIT_SUCCESS);
     
183. }
     

复制代码