请问消息队列比运用管道有什么优势？

home

请大家原谅我的难处，消息队列和信号量在书的例子很少，在《APUE》没有足够的例子，现在用法大概懂，但感觉很模糊，不好理解(参数)多，去网上搜那些例子太长了。看不明白。。请大家帮我解释一下和贴些简单的例子出来，拜托了。。。

还有个问题，为什么很多例子都是说客户机和服务器间的编程？帮帮忙呀。 :eek: :eek: :confused:

home

自己先贴些源码，为了方便看，在控制终端看不舒服

1. 
   
2. /* (c) Louis Granboulan 2000-2003 */
   
3. #include <stdio.h>
   
4. #include <stdlib.h>
   
5. #include <string.h>
   
6. #include <unistd.h>
   
7. #include <signal.h>
   
8. #include <sys/types.h>
   
9. #include <sys/ipc.h>
   
10. #include <sys/shm.h>
    
11. #include <sys/sem.h>
    
12. 
    
13. /*
    
14. * La file est cha頽閑
    
15. * Un maillon contient
    
16. *   [ shmid du maillon suivant ; debut, fin, tableau de requetes ]
    
17. *   le dernier maillon pointe sur lui-m阭e...
    
18. * Par rapport àl'exercice 1, enfile/defile a comme unique argument variable
    
19. *   le shmid du maillon courant.
    
20. *   NB: il n'est pas optimal de faire un lock àchaque acc鑣,
    
21. *   il vaudrait mieux que le s閙aphore indique le nombre de maillons.
    
22. * Autre diff閞ence : ce n'est plus le p鑢e qui supprime les IPC lorsque
    
23. *   le programme finit, mais le fils defileur.
    
24. */
    
25. #define TAILLE 10
    
26. struct requete { int code, valeur; };
    
27. struct maillon { int next; int debut, fin; struct requete tab[TAILLE]; };
    
28. int enfile(void);
    
29. int defile(void);
    
30. void ipcrm(int shmid, int semid, struct maillon *ici);
    
31. void sondied(int sig);
    
32. void ipcclean(int sig);
    
33.                                                                                                 
    
34. static struct sembuf op_lock[2] = {
    
35.         { 0,  0, 0 },
    
36.         { 0,  1, SEM_UNDO },
    
37. };
    
38.                                                                                                 
    
39. static struct sembuf op_unlock[1] = {
    
40.         { 0, -1, (IPC_NOWAIT | SEM_UNDO) },
    
41. };
    
42.                                                                                                 
    
43. int loop = 1;
    
44. /* Les trois suivantes sont globales pour 阾re accessible de "ipcclean" */
    
45. int shmid; /* bloc de m閙oire partag閑 */
    
46. int semid; /* s閙aphore */
    
47. struct maillon *ici; /* maillon courant */
    
48. int main(int argc, char **argv)
    
49. {
    
50.   int pidenfile, piddefile;
    
51.   semid = semget(IPC_PRIVATE,1,IPC_CREAT|SHM_R|SHM_W);
    
52.   if (semid==-1) { perror("semget"); exit(1); }
    
53.   shmid = shmget(IPC_PRIVATE, sizeof(struct maillon), IPC_CREAT|SHM_R|SHM_W);
    
54.   if (shmid==-1) { perror("shmget"); semctl(semid,0,IPC_RMID,0); exit(1); }
    
55.   ici = (struct maillon *) shmat(shmid,0,SHM_SHARE_MMU);
    
56.            [SIZE=4] /* SHM_SHAPE_MMU 是什么意思？ */[/size]
    
57.   if (ici==0) {
    
58.     perror("shmat");
    
59.     if (semctl(semid,0,IPC_RMID,0)) { perror("semctl"); }
    
60.     if (shmctl(shmid,IPC_RMID,0)) { perror("shmctl"); }
    
61.     exit(1);
    
62.   }
    
63.   ici->next = shmid;
    
64.   ici->debut = ici->fin = 0;
    
65.   pidenfile = fork();
    
66.   if (pidenfile<0) { perror("fork"); ipcrm(shmid,semid,ici); exit(1); }
    
67.   if (!pidenfile) {
    
68.     puts("Je suis le fils qui enfile");
    
69.     for ( ; ; ) {
    
70.       sleep(3600);
    
71.       if (enfile()) { puts("File pleine"); exit(1); }
    
72.     }
    
73.     exit(0);
    
74.   }
    
75.   piddefile = fork();
    
76.   if (piddefile<0) { perror("fork"); ipcrm(shmid,semid,ici); exit(1); }
    
77.   if (!piddefile) {
    
78.     puts("Je suis le fils qui defile");
    
79.     signal(SIGQUIT,ipcclean);
    
80.     signal(SIGTERM,ipcclean);
    
81.     signal(SIGINT,ipcclean);
    
82.     for ( ; ; ) {
    
83.       sleep(3600);
    
84.       if (defile()) { puts("File vide"); ipcrm(shmid,semid,ici); exit(1); }
    
85.     }
    
86.     ipcrm(shmid,semid,ici);
    
87.     exit(0);
    
88.   }
    
89.   signal(SIGCHLD,sondied);
    
90.   signal(SIGQUIT,sondied);
    
91.   signal(SIGTERM,sondied);
    
92.   signal(SIGINT,sondied);
    
93.   while (loop) {
    
94.     char buffer[80]; fgets(buffer,80,stdin);
    
95.     switch (buffer[0]) {
    
96.     case '>':
    
97.       kill(pidenfile,SIGALRM);
    
98.       break;
    
99.     case '<':
    
100.       kill(piddefile,SIGALRM);
     
101.       break;
     
102.     default:
     
103.       puts("Quit");
     
104.       loop = 0;
     
105.     }
     
106.   }
     
107.   kill(pidenfile,SIGTERM);
     
108.   kill(piddefile,SIGTERM);
     
109.   /* ipcrm(shmid,semid,ici);  C'est le fils qui d閒ile qui s'en charge */
     
110.   return 0;
     
111. }
     
112. void sondied(int sig) { loop = 0; }
     
113. void ipcclean(int sig) { ipcrm(shmid, semid, ici); }
     
114.                                                                                                 
     
115. void ipcrm(int shmid, int semid, struct maillon *ici)
     
116. {
     
117.   int next;
     
118.   if (semctl(semid,0,IPC_RMID,0)) { perror("semctl"); }
     
119.   while (ici && ici->next != shmid) {
     
120.     next = ici->next;
     
121.     shmdt((void*)ici);
     
122.     if (shmctl(shmid,IPC_RMID,0)) { perror("shmctl"); }
     
123.     shmid = next;
     
124.   }
     
125.   if (ici) shmdt((void*)ici);
     
126.   if (shmctl(shmid,IPC_RMID,0)) { perror("shmctl"); }
     
127. }
     
128.                                                                                                 
     
129. int enfile()
     
130. {
     
131.   int shmnew;
     
132.   puts("Enfile");
     
133.   if (semop(semid, op_lock, 2) < 0) { perror("semop"); exit(1); }
     
134.   ici->fin++;
     
135.   if (ici->fin == TAILLE) {
     
136.     puts("Cr閍tion d'un maillon");
     
137.     shmnew = shmget(IPC_PRIVATE, sizeof(struct maillon), IPC_CREAT|SHM_R|SHM_W);
     
138.     if (shmnew==-1) {
     
139.       perror("shmget");
     
140.       ipcrm(shmid, semid, ici);
     
141.       exit(1);
     
142.     }
     
143.     ici->next = shmnew; shmid = shmnew;
     
144.     ici = (struct maillon *) shmat(shmid,0,SHM_SHARE_MMU);
     
145.     if (ici==0) { perror("shmat"); exit(2); }
     
146.     ici->next = shmid;
     
147.     ici->debut = ici->fin = 0;
     
148.     ici->fin++;
     
149.   }
     
150.   if (semop(semid, op_unlock, 1) < 0) { perror("semop"); exit(1); }
     
151.   return 0;
     
152. }
     
153. int defile()
     
154. {
     
155.   puts("Defile");
     
156.   if (semop(semid, op_lock, 2) < 0) { perror("semop"); exit(1); }
     
157.   if (ici->debut == ici->fin) {
     
158.     if (semop(semid, op_unlock, 1) < 0) { perror("semop"); exit(1); }
     
159.     return 1;
     
160.   }
     
161.   ici->debut++;
     
162.   if (ici->debut == TAILLE) {
     
163.     int next = ici->next;
     
164.     puts("Destruction d'un maillon");
     
165.     shmdt((void*)ici);
     
166.     if (shmctl(shmid,IPC_RMID,0)) { perror("shmctl"); }
     
167.     shmid = next;
     
168.     ici = (struct maillon *) shmat(shmid,0,SHM_SHARE_MMU);
     
169.     if (ici==0) { perror("shmat"); exit(2); }
     
170.   }
     
171.   if (semop(semid, op_unlock, 1) < 0) { perror("semop"); exit(1); }
     
172.   return 0;
     
173. }
     

复制代码

请斑竹们体谅一下。。:rolleyes: 有简单点的例子吗？？:confused: :confused:

home

1. 
   
2. #include <stdio.h>
   
3. #include <unistd.h>
   
4. #include <sys/shm.h>
   
5. #include <sys/sem.h>
   
6. #include <strings.h>
   
7. #include <pthread.h>
   
8. #include "sem.h"
   
9. #include "pc.h"
   
10. 
    
11. static int yin_shmid;
    
12. static int yin_filled, yin_empty, yin_mutex;
    
13. static int yang_shmid;
    
14. static int yang_filled, yang_empty, yang_mutex;
    
15. static char *yin_shmem_ptr;
    
16. static char *yang_shmem_ptr;
    
17. 
    
18. /*
    
19. *   Remove shared memory IDs and semaphores.
    
20. *   Ignore errors since maybe not all exist.
    
21. */
    
22. static void yin_cleanup()
    
23. {
    
24.         (void) shmdt(yin_shmem_ptr);
    
25.         (void) shmdt(yang_shmem_ptr);
    
26. 
    
27.         (void) shmctl(yin_shmid, IPC_RMID, NULL);
    
28.         (void) shmctl(yang_shmid, IPC_RMID, NULL);
    
29.         (void) semctl(yin_filled, 0, IPC_RMID);
    
30.         (void) semctl(yin_empty, 0, IPC_RMID);
    
31.         (void) semctl(yin_mutex, 0, IPC_RMID);
    
32.         (void) semctl(yang_filled, 0, IPC_RMID);
    
33.         (void) semctl(yang_empty, 0, IPC_RMID);
    
34.         (void) semctl(yang_mutex, 0, IPC_RMID);
    
35. 
    
36.                                                                                                 
    
37.         exit(0);
    
38. }
    
39.                                                                                                 
    
40. static void yin_init()
    
41. {
    
42. /* create shared memory segments */
    
43.         if ((yin_shmid = shmget(IPC_PRIVATE, SHMSUS, 0600)) < 0) {
    
44.                 perror("1st shmget"); yin_cleanup();
    
45.         }
    
46.         if ((yang_shmid = shmget(IPC_PRIVATE, SHMSUS, 0600)) < 0) {
    
47.                 perror("2nd shmget"); yin_cleanup();
    
48.         }
    
49. /* attach to shared memory segments */
    
50.         if ((int)(yin_shmem_ptr = (char *) shmat(yin_shmid, (void *)0, SHM_SHATTR)) < 0) {
    
51.                 perror("1st shmat"); yin_cleanup();
    
52.         }
    
53.         if ((int)(yang_shmem_ptr = (char *) shmat(yang_shmid, (void *)0, SHM_SHATTR)) < 0) {
    
54.                 perror("2nd shmat"); yin_cleanup();
    
55.         }
    
56.                                                                                                 
    
57. /* create semaphores */
    
58.         if ((yin_filled = semget(IPC_PRIVATE, 1, 0600)) < 0) {
    
59.                 perror("yin_filled semget"); yin_cleanup();
    
60.         }
    
61.         Init(yin_filled, 0);
    
62.         if ((yin_empty = semget(IPC_PRIVATE, 1, 0600)) < 0) {
    
63.                 perror("yin_empty semget"); yin_cleanup();
    
64.         }
    
65.         Init(yin_empty, 1);
    
66.         if ((yin_mutex = semget(IPC_PRIVATE, 1, 0600)) < 0) {
    
67.                 perror("yin_mutex semget"); yin_cleanup();
    
68.         }
    
69.         Init(yin_mutex, 1);
    
70.         if ((yang_filled = semget(IPC_PRIVATE, 1, 0600)) < 0) {
    
71.                 perror("yang_filled semget"); yin_cleanup();
    
72.         }
    
73.         Init(yang_filled, 0);
    
74.         if ((yang_empty = semget(IPC_PRIVATE, 1, 0600)) < 0) {
    
75.                 perror("yang_empty semget"); yin_cleanup();
    
76.         }
    
77.         Init(yang_empty, 1);
    
78.         if ((yang_mutex = semget(IPC_PRIVATE, 1, 0600)) < 0) {
    
79.                 perror("yang_mutex semget"); yin_cleanup();
    
80.         }
    
81.         Init(yang_mutex, 1);
    
82.                                                                                                 
    
83.         return;
    
84. }
    
85.                                                                                                 
    
86. int main()  /*                  main()                    */
    
87. {
    
88.         args_t produce_args;
    
89.         args_t consume_args;
    
90.         pthread_t second_thread;
    
91.                                                                                                 
    
92.         yin_init();
    
93.                                                                                                 
    
94. /* start consumer thread to read from yang */
    
95.         consume_args.filled_sem = yang_filled;
    
96.         consume_args.empty_sem = yang_empty;
    
97.         consume_args.mutex_sem = yang_mutex;
    
98.         consume_args.ptr = yang_shmem_ptr;
    
99.         consume_args.cleanup_func = yin_cleanup;
    
100.         if (pthread_create(&second_thread,
     
101.                            NULL,
     
102.                            Consume,
     
103.                            (void *)&consume_args) != 0) {
     
104.                 perror("pthread_create"); yin_cleanup();
     
105.         }
     
106. /* print shmid & semid only AFTER all initialization has succeeded */
     
107.         printf("You will have to type this stuff into yang ...\n");
     
108.         printf("Yin writes into shared memory ID %d\n", yin_shmid);
     
109.         printf("\t Filled semaphore number: %d\n", yin_filled);
     
110.         printf("\t Empty semaphore number: %d\n", yin_empty);
     
111.         printf("\t Mutex semaphore number: %d\n", yin_mutex);
     
112.         printf("Yang writes into shared memory ID %d\n", yang_shmid);
     
113.         printf("\t Filled semaphore number: %d\n", yang_filled);
     
114.         printf("\t Empty semaphore number: %d\n", yang_empty);
     
115.         printf("\t Mutex semaphore number: %d\n", yang_mutex);
     
116.                                                                                                 
     
117. /* this thread starts produce loop */
     
118.         produce_args.filled_sem = yin_filled;
     
119.         produce_args.empty_sem = yin_empty;
     
120.         produce_args.mutex_sem = yin_mutex;
     
121.         produce_args.ptr = yin_shmem_ptr;
     
122.         (void) Produce(&produce_args);
     
123.                                                                                                 
     
124. /* delete resources */
     
125.         yin_cleanup();          /* never returns */
     
126.         return(0);
     
127. }
     

复制代码

home

1. 
   
2. /* $Header: p3.c,v 1.3 97/11/26 15:32:54 cs096403 Exp $ */
   
3. /*
   
4. * P3 BY Jeff Anderson, CSCI 325-01, Due: 11/26/97
   
5. * PROGRAM ID:  p3.c / Conway's problem (Concurrent version using semaphores)
   
6. * AUTHOR:  Jeff Anderson
   
7. * INSTALLATION:  MIDDLE TENNESSEE STATE UNIVERSITY
   
8. *
   
9. * REMARKS:  This program reads 10-character blocks (from standard input)
   
10. * and writes them as 24-character lines (to standard output) with the
    
11. * following changes:
    
12. *     - After every block an extra blank is inserted.
    
13. *     - Every adjacent pair of asterisks is replaced by
    
14. *       an exclamation point.  Asterisks are considered
    
15. *       adjacent only if they are in the same block.
    
16. * The newline character is not considered as a delimiter of an input block
    
17. * and is ignored in input.  (However, the newline character is used as a
    
18. * sentinel value between the child processes to denote the end of the
    
19. * input stream.)
    
20. *
    
21. * INVOCATION:  This program is invoked on the command-line with two
    
22. * arguments, the first is the size (in characters) of the buffer used
    
23. * between the "readinput" and "squash" processes.  The second is the
    
24. * size (in characters) of the buffer used between the "squash" and
    
25. * "printoutput" processes.  Since this program runs as a filter, an
    
26. * input file will usually be redirected into it.
    
27. * For example,         % p3 5 9  <  data.file
    
28. */
    
29. #include <stdio.h>
    
30. #include <stdlib.h>
    
31. #include <signal.h>
    
32. #include <unistd.h>
    
33. #include <sys/wait.h>
    
34. #include <sys/ipc.h>
    
35. #include <sys/sem.h>
    
36. #include <sys/shm.h>
    
37.                                                                                                 
    
38. #include "IPC.h"
    
39. #include "p3.h"
    
40.                                                                                                 
    
41.                                                                                                 
    
42. /* --- Global Variables, shared by main() and CleanupIPC() ---------------- */
    
43. int     pid_readinput;     /* readinput process id                          */
    
44. int     pid_squash;        /* squash process id                             */
    
45. int     pid_printoutput;   /* printoutput process id                        */
    
46.                                                                                                 
    
47.                                                                                                 
    
48.                                                                                                 
    
49. /* --- Functions ---------------------------------------------------------- */
    
50. void
    
51. CleanupIPC(int sig) {
    
52.         sem[NR]!=-1    ? semctl(sem[NR], 0,  IPC_RMID, 0) : 0;
    
53.         sem[ER]!=-1    ? semctl(sem[ER], 0,  IPC_RMID, 0) : 0;
    
54.         sem[NS]!=-1    ? semctl(sem[NS], 0,  IPC_RMID, 0) : 0;
    
55.         sem[ES]!=-1    ? semctl(sem[ES], 0,  IPC_RMID, 0) : 0;
    
56.         shm[RB]!=-1    ? shmctl(shm[RB],     IPC_RMID, 0) : 0;
    
57.         shm[SB]!=-1    ? shmctl(shm[SB],     IPC_RMID, 0) : 0;
    
58.         if (sig==0)
    
59.                 return;
    
60.                                                                                                 
    
61.         else {
    
62.                 (void) fprintf(stderr,
    
63.                   "Error: p3 main() received signal %d\n", sig);
    
64.                                                                                                 
    
65.                 /* Explicitly signal children to die. */
    
66.                 kill(pid_readinput, SIGKILL);
    
67.                 kill(pid_squash, SIGKILL);
    
68.                 kill(pid_printoutput, SIGKILL);
    
69.                                                                                                 
    
70.                 exit(FAILURE);
    
71.         }
    
72. }
    
73. int
    
74. main(int argc, char * argv[]) {
    
75.                                                                                                 
    
76.         int     read_buffer_capacity;    /* Capacity of Read Buffer       */
    
77.         int     squash_buffer_capacity;  /* Capacity of Squash Buffer     */
    
78.         char *  readinput_args[7];       /* readinput's argument vector   */
    
79.         char *  squash_args[10];         /* squash's argument vector      */
    
80.         char *  printoutput_args[7];     /* printoutput's argument vector */
    
81.         int     sig;                     /* Signal number                 */
    
82.         int     return_status, return_code;
    
83.                                                                                                 
    
84.                                                                                                 
    
85.         /* Process command-line arguments. */
    
86.         if (argc != 3) {
    
87.                 ERROR("Missing command-line argument(s) to p3");
    
88.                 exit(FAILURE);
    
89.         }
    
90.                                                                                                 
    
91.         else {
    
92.                 read_buffer_capacity   = atoi(argv[1]);
    
93.                 squash_buffer_capacity = atoi(argv[2]);
    
94.         }
    
95.         /* Cause all signals to be caught by the "CleanupIPC" routine.
    
96.          * The specific number of signals is somewhat system dependent;
    
97.          * the top value (NSIG from signal.h) may need adjustment.
    
98.          * NOTE: this implementation assumes that "Reliable Signal"
    
99.          * semantics are implemented with signal().  If this isn't true,
    
100.          * the sigaction() routine will need to be used.  See Stevens,
     
101.          * Chapter 10 (especially pp. 296-299) for more information.
     
102.         */
     
103.         for (sig=1; sig < NSIG; sig++) {
     
104.                                                                                                 
     
105.                 switch(sig) {
     
106.                 /* Don't try to catch these signals    */
     
107.                 case SIGKILL: case SIGSTOP: case SIGCHLD:
     
108.                         break;
     
109.                                                                                                 
     
110.                 default:
     
111.                         if ( signal(sig, CleanupIPC)==SIG_ERR) {
     
112.                                 (void) fprintf(stderr,
     
113.                                   "Error: unable to catch signal %d", sig);
     
114.                         }
     
115.                         break;
     
116.                 }
     
117.         }
     
118.         /* Set-up and initialize semaphores. */
     
119.         sem[NR] = SemaphoreInit(0);
     
120.         sem[ER] = SemaphoreInit(read_buffer_capacity);
     
121.         sem[NS] = SemaphoreInit(0);
     
122.         sem[ES] = SemaphoreInit(squash_buffer_capacity);
     
123.                                                                                                 
     
124.                                                                                                 
     
125.         /* Set-up shared memory. */
     
126.         shm[RB] = shmget(IPC_PRIVATE, read_buffer_capacity,   0600);
     
127.         shm[SB] = shmget(IPC_PRIVATE, squash_buffer_capacity, 0600);
     
128.                                                                                                 
     
129.                                                                                                 
     
130.         /* --- Invoke the "readinput" routine --- */
     
131.         /*
     
132.          * Set up argument list for invocation of the child process.
     
133.          * Note that the following assignments merely assign to the
     
134.          * args array the addresses where the argument values will be
     
135.          * found and NOT the actual argument values themselves.
     
136.         */
     
137.         readinput_args[0] = "readinput";   /* Name of child executable image. */
     
138.         readinput_args[1] = semstr[NR];
     
139.         readinput_args[2] = semstr[ER];
     
140.         readinput_args[3] = argv[1];       /* Read buffer capacity. */
     
141.         readinput_args[4] = shmstr[RB];
     
142.         readinput_args[5] = shmstr[SB];
     
143.         readinput_args[6] = NULL;
     
144.         sprintf(semstr[NR], "%d", sem[NR]);
     
145.         sprintf(semstr[ER], "%d", sem[ER]);
     
146.         sprintf(shmstr[RB], "%d", shm[RB]);
     
147.         sprintf(shmstr[SB], "%d", shm[SB]);
     
148.                                                                                                 
     
149.         if ( (pid_readinput = fork()) < 0) {
     
150.                                                                                                 
     
151.                 OS_ERROR("Can't fork to run readinput.");
     
152.                 exit(errno);
     
153.         }
     
154.                                                                                                 
     
155.         else {
     
156.                                                                                                 
     
157.                 if (pid_readinput == 0) {   /* Child process:  run readinput. */
     
158.                                                                                                 
     
159.                         execvp("readinput",readinput_args);
     
160.                         OS_ERROR("Invocation of readinput failed.");
     
161.                         _exit( FAILURE );
     
162.                 }
     
163.         }
     
164.         /* From this point on, we are running concurrently with readinput. */
     
165.                                                                                                 
     
166.                                                                                                 
     
167.         /* --- Invoke the "squash" routine --- */
     
168.         /*
     
169.          * Set up argument list for invocation of the child process.
     
170.          * Note that the following assignments merely assign to the
     
171.          * args array the addresses where the argument values will be
     
172.          * found and NOT the actual argument values themselves.
     
173.         */
     
174.         squash_args[0] = "squash";         /* Name of child executable image. */
     
175.         squash_args[1] = semstr[NR];
     
176.         squash_args[2] = semstr[ER];
     
177.         squash_args[3] = argv[1];          /* Read buffer capacity. */
     
178.         squash_args[4] = semstr[NS];
     
179.         squash_args[5] = semstr[ES];
     
180.         squash_args[6] = argv[2];          /* Squash bufffer capacity. */
     
181.         squash_args[7] = shmstr[RB];
     
182.         squash_args[8] = shmstr[SB];
     
183.         squash_args[9] = NULL;
     
184.                                                                                                 
     
185.         sprintf(semstr[NR], "%d", sem[NR]);
     
186.         sprintf(semstr[ER], "%d", sem[ER]);
     
187.         sprintf(semstr[NS], "%d", sem[NS]);
     
188.         sprintf(semstr[ES], "%d", sem[ES]);
     
189.         sprintf(shmstr[RB], "%d", shm[RB]);
     
190.         sprintf(shmstr[SB], "%d", shm[SB]);
     
191.         if ( (pid_squash = fork()) < 0) {
     
192.                                                                                                 
     
193.                 OS_ERROR("Can't fork to run squash.");
     
194.                 exit(errno);
     
195.         }
     
196.         else {
     
197.                                                                                                 
     
198.                 if (pid_squash == 0) {   /* Child process:  run squash. */
     
199.                                                                                                 
     
200.                         execvp("squash",squash_args);
     
201.                         OS_ERROR("Invocation of squash failed.");
     
202.                         _exit( FAILURE );
     
203.                 }
     
204.         }
     
205.         /* From this point on, we are running concurrently with squash. */
     
206.                                                                                                 
     
207.                                                                                                 
     
208.                                                                                                 
     
209.         /* --- Invoke the "printoutput" routine --- */
     
210.         /*
     
211.          * Set up argument list for invocation of the child process.
     
212.          * Note that the following assignments merely assign to the
     
213.          * args array the addresses where the argument values will be
     
214.          * found and NOT the actual argument values themselves.
     
215.         */
     
216.         printoutput_args[0] = "printoutput";   /* Name of child executable image. */
     
217.         printoutput_args[1] = semstr[NS];
     
218.         printoutput_args[2] = semstr[ES];
     
219.         printoutput_args[3] = argv[2];         /* Squash buffer capacity. */
     
220.         printoutput_args[4] = shmstr[RB];
     
221.         printoutput_args[5] = shmstr[SB];
     
222.         printoutput_args[6] = NULL;
     
223.                                                                                                 
     
224.         sprintf(semstr[NR], "%d", sem[NS]);
     
225.         sprintf(semstr[ER], "%d", sem[ES]);
     
226.         sprintf(shmstr[RB], "%d", shm[RB]);
     
227.         sprintf(shmstr[SB], "%d", shm[SB]);
     
228.                                                                                                 
     
229.         if ( (pid_printoutput = fork()) < 0) {
     
230.                                                                                                 
     
231.                 OS_ERROR("Can't fork to run printoutput.");
     
232.                 exit(errno);
     
233.         }
     
234.                                                                                                 
     
235.         else {
     
236.                                                                                                 
     
237.                 if (pid_printoutput == 0) {   /* Child process:  run printoutput. */
     
238.                                                                                                 
     
239.                         execvp("printoutput",printoutput_args);
     
240.                         OS_ERROR("Invocation of printoutput failed.");
     
241.                         _exit( FAILURE );
     
242.                 }
     
243.         }
     
244.         /* From this point on, we are running concurrently with printoutput. */
     
245.         /* Finalizations */
     
246.                                                                                                 
     
247.         /* Wait until readinput finished. */
     
248.         waitpid(pid_readinput, &return_status, 0);
     
249.         return_code = WIFEXITED(return_status);
     
250.                                                                                                 
     
251.         /* Wait until squash finished. */
     
252.         waitpid(pid_squash, &return_status, 0);
     
253.         return_code = WIFEXITED(return_status);
     
254.                                                                                                 
     
255.         /* Wait until printoutput finished. */
     
256.         waitpid(pid_printoutput, &return_status, 0);
     
257.         return_code = WIFEXITED(return_status);
     
258.                                                                                                 
     
259.         CleanupIPC( 0 );
     
260.                                                                                                 
     
261.         exit(SUCCESS);
     
262. }
     

复制代码

kj501

http://www-900.ibm.com/developer ... c/part3/index.shtml
http://www-900.ibm.com/developer ... c/part1/index.shtml