unix 仅用信号同步N进程

m1m5dgzv  于 2022-11-04  发布在  Unix
关注(0)|答案(1)|浏览(242)

我正在做一个操作系统课程的练习。为了学习使用信号（我的一个弱点），我想尝试只用信号同步N个进程。但是我做不到。
代码为：

  2. # include "Header.h"
  4. # include <signal.h>
  6. // first sigHandler
  7. void sigHandler(int signum)
  8. {    
  9.     printf("Received signal\n");
  10. }
  12. // second sigHandler
  13. void sigHandler2(int signum)
  14. {
  15.     printf("Received other signal\n");
  16. }
  18. int main(int argc, char *argv[])
  19. {
  20.     // Number of process
  21.     int N = 2;
  23.     // Assign sigHandlers
  24.     signal(SIGUSR1, sigHandler);
  25.     signal(SIGUSR2, sigHandler2);
  27.     // array for pids to activate in order;
  28.     pid_t pid[N];
  30.     int i;
  32.     for (i = 0; i < N; i++)
  33.     {
  34.         // creation child
  35.         pid[i] = fork();
  37.         if (pid == 0)
  38.         {
  39.             // if is the last child, resume the father
  40.             if (i == N - 1)
  41.             {
  42.                 kill(getppid(), SIGUSR2);
  43.             }
  45.             // expect SIGUSR1
  46.             pause();
  47.             printf("%i completed\n", getpid());
  48.             exit(0);
  49.         }
  50.     }
  52.     // expext that all child started
  53.     pause();
  55.     // active the last child
  56.     i--;
  57.     kill(pid[i], SIGUSR1);
  58.     signal(SIGUSR1, sigHandler);
  60.     // active other child
  61.     while (wait(NULL) != -1)
  62.     {
  63.         i--;
  64.         kill(pid[i], SIGUSR1);
  65.         signal(SIGUSR1, sigHandler);
  66.     }
  67.     printf("All fine\n");
  68.     exit(0);
  69. }

我尝试用sleep(10)替换pause()系统，但结果是终端上出现四条“All fine”消息。
我猜想这个问题源于信号的异步特性，但我不知道如何解决它。

unix

1条答案

按热度按时间
whitzsjs

whitzsjs1#

问题的主要部分是测试if (pid == 0)-数组地址不为空。您的意思是if (pid[i] == 0)！
通过这些更改以及使代码在我的默认编译选项（非常繁琐）下编译所需的最小更改，我从程序sig79中得到了以下输出：

  1. $ sig79
  2. Received other signal
  3. Received signal
  4. 15312 completed
  5. Received signal
  6. 15311 completed
  7. All fine
  8. $

在调试问题时，我使用了这段代码，它有大量的打印内容（部分原因是我被有缺陷的测试弄糊涂了）。我使用等待循环是因为在某些情况下，您的父进程可能会有它没有创建的子进程--这些情况很模糊，但这段代码说明了这些情况。注意，子进程退出时的状态与子进程编号相对应;您可以在等待循环中报告的退出状态中看到这些数字。

  2. # include <assert.h>
  4. # include <signal.h>
  6. # include <stdio.h>
  8. # include <stdlib.h>
  10. # include <sys/wait.h>
  12. # include <unistd.h>
  14. static void write_msg(size_t len, char *msg)
  15. {
  16.     int pid = getpid();
  17.     for (int i = 5; i > 0; i--)
  18.     {
  19.         msg[i-1] = pid % 10 + '0';
  20.         pid /= 10;
  21.     }
  22.     write(STDOUT_FILENO, msg, len);
  23. }
  25. // first sigHandler
  26. static void sigHandler1(int signum)
  27. {    
  28.     assert(signum == SIGUSR1);
  29.     static char msg[] = "XXXXX: Received signal SIGUSR1\n";
  30.     write_msg(sizeof(msg) - 1, msg);
  31. }
  33. // second sigHandler
  34. static void sigHandler2(int signum)
  35. {
  36.     assert(signum == SIGUSR2);
  37.     static char msg[] = "XXXXX: Received signal SIGUSR2\n";
  38.     write_msg(sizeof(msg) - 1, msg);
  39. }
  41. int main(void)
  42. {
  43.     // Number of process
  44.     int N = 2;
  46.     // Assign sigHandlers
  47.     signal(SIGUSR1, sigHandler1);
  48.     signal(SIGUSR2, sigHandler2);
  50.     printf("%d: parent at work\n", getpid());
  52.     // array for pids to activate in order;
  53.     pid_t pid[N];
  55.     for (int i = 0; i < N; i++)
  56.     {
  57.         // creation child
  58.         pid[i] = fork();
  60.         if (pid[i] == 0)
  61.         {
  62.             printf("%d: child %d at play\n", getpid(), i+1);
  63.             // if is the last child, resume the father
  64.             if (i == N - 1)
  65.             {
  66.                 kill(getppid(), SIGUSR2);
  67.                 printf("%d: signal SIGUSR2 sent to PID %d\n", getpid(), getppid());
  68.             }
  70.             // expect SIGUSR1
  71.             pause();
  72.             printf("%d: child %d completed\n", getpid(), i+1);
  73.             exit(i+1);
  74.         }
  75.         printf("%d: child %d has PID %d\n", getpid(), i+1, pid[i]);
  76.         fflush(stdout);
  77.     }
  79.     // expect that all children started
  80.     pause();
  82.     for (int i = N; i > 0; i--)
  83.     {
  84.         kill(pid[i - 1], SIGUSR1);
  85.         printf("%d: signal SIGUSR1 sent to child %d PID %d\n", getpid(), i, pid[i - 1]);
  86.         int corpse;
  87.         int status;
  88.         while ((corpse = wait(&status)) > 0)
  89.         {
  90.             if (corpse == pid[i - 1])
  91.             {
  92.                 printf("%d: child %d PID %d exited with status 0x%.4X\n",
  93.                        getpid(), i, corpse, status);
  94.                 break;
  95.             }
  96.             else
  97.                 printf("%d: unexpected child PID %d exited with status 0x%.4X\n",
  98.                        getpid(), corpse, status);
  99.         }
  100.     }
  102.     printf("%d: All fine\n", getpid());
  103.     return(0);
  104. }

有一次，当我运行程序（sig59）时，我得到了输出：

  1. $ sig59
  2. 15177: parent at work
  3. 15177: child 1 has PID 15178
  4. 15178: child 1 at play
  5. 15177: child 2 has PID 15179
  6. 15179: child 2 at play
  7. 15179: signal SIGUSR2 sent to PID 15177
  8. 15177: Received signal SIGUSR2
  9. 15177: signal SIGUSR1 sent to child 2 PID 15179
  10. 15179: Received signal SIGUSR1
  11. 15179: child 2 completed
  12. 15177: child 2 PID 15179 exited with status 0x0200
  13. 15177: signal SIGUSR1 sent to child 1 PID 15178
  14. 15178: Received signal SIGUSR1
  15. 15178: child 1 completed
  16. 15177: child 1 PID 15178 exited with status 0x0100
  17. 15177: All fine
  18. $

并且，为了证明模糊情况可能发生：

  1. $ forker -s 0 -c 'exit 37' -- ./sig59
  2. forker: Setting number of child processes to 3
  3. 15138: forker at work
  4. 15138: launched 15139
  5. 15138: launched 15140
  6. 15138: launched 15141
  7. 15138: executing ./sig59
  8. 15138: parent at work
  9. 15138: child 1 has PID 15142
  10. 15138: child 2 has PID 15143
  11. 15142: child 1 at play
  12. 15143: child 2 at play
  13. 15143: signal SIGUSR2 sent to PID 15138
  14. 15138: Received signal SIGUSR2
  15. 15138: signal SIGUSR1 sent to child 2 PID 15143
  16. 15143: Received signal SIGUSR1
  17. 15143: child 2 completed
  18. 15138: child 2 PID 15143 exited with status 0x0200
  19. 15138: signal SIGUSR1 sent to child 1 PID 15142
  20. 15138: unexpected child PID 15139 exited with status 0x2500
  21. 15142: Received signal SIGUSR1
  22. 15142: child 1 completed
  23. 15138: unexpected child PID 15140 exited with status 0x2500
  24. 15138: unexpected child PID 15141 exited with status 0x2500
  25. 15138: child 1 PID 15142 exited with status 0x0100
  26. 15138: All fine
  27. $

forker程序运行三个进程，每个进程依次运行exit 37（十六进制0x 25），然后执行sig59进程（它不知道它以前的子进程是forker进程）。

展开查看全部
赞(0）分享  回复(0）举报  2022-11-04
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com