分叉、信号以及它们如何与 C 中的全局变量交互

发布于 2024-10-08 15:11:41 字数 1365 浏览 2 评论 0原文

我试图了解 fork()/Linux 内核如何处理全局变量。

给定代码：

#include<signal.h>
#include<unistd.h>
#include<stdio.h>
#include<errno.h>
#include <sys/types.h>

pid_t pid;
int counter = 2;
void handler1(int sig)
{
 counter = counter - 1;
 printf("%d", counter);
 exit(0);
}
int main()
{
    signal(SIGUSR1, handler1); //Install Handler
    printf("%d", counter);     //Print Parent global variable
    pid = fork( );             //Fork(), child pid = 0, parent's pid = positive int.
    if (pid == 0)              //Parent skips this, child goes into infinite loop
    {
      while(1) {}; // simulate doing some work
    }
    kill(pid, SIGUSR1);        //While child is the loop, parents calls to terminate the child. 
                               //Child will stop the infinite loop, and will not proceed any 
                               //Will it call handler1 ???

    wait(NULL);                //Wait for child to be ripped
                               //Will it call handler1 second time ???
    counter = counter + 1;     //This will surely increment global variable
    printf("%d", counter);
    exit(0);
}

输出为 2123 调用 fork() 和信号处理程序后，Unix/Linux 内核如何处理全局变量？？？它们是否在孩子和孩子之间共享？家长？

我对这段代码遇到的另一个问题是如何kill() & wait() 将处理全局变量以及它们将使用什么集合 - 父母的还是孩子的？他们会调用信号处理程序吗？？？

谢谢！

原文

I am trying to understand how fork()/Linux Kernel deals with global variables.

Given code:

#include<signal.h>
#include<unistd.h>
#include<stdio.h>
#include<errno.h>
#include <sys/types.h>

pid_t pid;
int counter = 2;
void handler1(int sig)
{
 counter = counter - 1;
 printf("%d", counter);
 exit(0);
}
int main()
{
    signal(SIGUSR1, handler1); //Install Handler
    printf("%d", counter);     //Print Parent global variable
    pid = fork( );             //Fork(), child pid = 0, parent's pid = positive int.
    if (pid == 0)              //Parent skips this, child goes into infinite loop
    {
      while(1) {}; // simulate doing some work
    }
    kill(pid, SIGUSR1);        //While child is the loop, parents calls to terminate the child. 
                               //Child will stop the infinite loop, and will not proceed any 
                               //Will it call handler1 ???

    wait(NULL);                //Wait for child to be ripped
                               //Will it call handler1 second time ???
    counter = counter + 1;     //This will surely increment global variable
    printf("%d", counter);
    exit(0);
}

The output is 2123
How does Unix/Linux kernel deals with global variables after fork() and signal handlers are called ??? Do they get shared between child & parent ?

Another issues I have with this code, is how kill() & wait() will deal with global variables and what set will they use - parent's or child's ?? And will they call signal handler ???

Thanks !

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

赠我空喜 2024-10-15 15:11:41

子级获得全局变量的独立副本。这两个副本不共享。

回复收藏 0 原文

望喜 2024-10-15 15:11:41

在fork()之后，整个过程，包括所有全局变量，都会被重复。子级是父级的精确副本，只不过它有不同的 PID、不同的父级，并且 fork() 返回 0。

子级中的信号处理程序将使用子级的全局变量的独立副本。

您看到 2 打印两次的原因是您在打印后没有刷新标准输出。发生的情况如下：

counter 等于 2。
父进程执行 printf("%d", counter);，这会将 "2" 进入 stdout 输出缓冲区，但不刷新它。尚未出现任何输出。
调用fork()，这会重复该过程。现在有两个 counter 变量的副本，并且都设置为 2。还有两个 stdout 输出缓冲区的实例，它们都包含字符串 “2”。尚未出现任何输出。
父级向子级发送 SIGUSR1，并在 wait() 上阻塞。
子进程执行 handler1()，将子进程的 counter 副本减为 1，并将 "1" 放入子进程的 stdout 输出缓冲区（现在包含“21”）。
子进程执行 exit(0)，其副作用是刷新 stdout。现在出现输出 "21"，由子进程写入，然后子进程退出。
wait() 在父进程中返回。父级将其 counter 副本增加到 3，然后将 "3" 打印到其 stdout 输出缓冲区（现在包含 " 23")。
父级执行 exit(0)，其副作用是刷新 stdout。现在出现输出 "23"，并且父进程退出。