wait() 函数行为

发布于 2024-12-10 08:34:56 字数 682 浏览 0 评论 0原文

我有以下代码:

#include <stdio.h>
main(int argc, char *argv[])
{
    int n,st;
    n = atoi(argv[1]);
    while(n*fork()) {
        printf("%d %d\n",getpid(), getppid());
        n--;
        printf("%d\n", wait(&st));
        printf("------\n");
    }
}

我执行此代码并得到以下结果:

bash-3.2$ ./test 3
10218 9948
10219
------
10218 9948
10220
------
10218 9948
10221
------

这是我的想法: 父级正在创建一个子级:

10218 9948

但是之后,我不明白为什么 printf("%d\n", wait(&st)); 返回此 id:10219< /强>。

wait() 应该返回终止的子进程的 id。

有人可以帮忙吗?

I have the following code:

#include <stdio.h>
main(int argc, char *argv[])
{
    int n,st;
    n = atoi(argv[1]);
    while(n*fork()) {
        printf("%d %d\n",getpid(), getppid());
        n--;
        printf("%d\n", wait(&st));
        printf("------\n");
    }
}

I execute this code and I get the following results:

bash-3.2$ ./test 3
10218 9948
10219
------
10218 9948
10220
------
10218 9948
10221
------

here are my thoughts:
The parent is creating a child:

10218 9948

But after, I don't understand why the printf("%d\n", wait(&st)); returns this id: 10219.

The wait() should return the id of the child that terminates.

Can anyone help?!

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

扫码二维码加入Web技术交流群

发布评论

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

评论(3

萌吟 2024-12-17 08:34:56

等待不是阻塞,因为没有理由阻塞。孩子已经执行完了。这是因为 Linux 会安排“子”进程先运行。

以下是图表形式发生的情况:

bash(9948)
|
|       main(10218)       child1(10219)       child2(10220)      child3(10221)
>-------------->
               |
             fork--------------->
                                |
                            while(0);
                            terminate;
                                |
             print 10218 9948---<
             wait (no block)
             print 10219
              |
             fork----------------------------------->
                                                    |
                                                while(0);
                                                terminate;
                                                    |
             print 10218 9948-----------------------<
             wait (no block)
             print 10220
              |
             fork----------------------------------------------------->
                                                                      |
                                                                  while(0);
                                                                  terminate;
                                                                      |
             print 10218 9948-----------------------------------------<
             wait (no block)
             print 10221
             terminate
               |
---------------<

Wait is not blocking because there's no reason to block. The child has already finished execution. This is because Linux will schedule the "child" process to run first.

Here is what's happening in graph form:

bash(9948)
|
|       main(10218)       child1(10219)       child2(10220)      child3(10221)
>-------------->
               |
             fork--------------->
                                |
                            while(0);
                            terminate;
                                |
             print 10218 9948---<
             wait (no block)
             print 10219
              |
             fork----------------------------------->
                                                    |
                                                while(0);
                                                terminate;
                                                    |
             print 10218 9948-----------------------<
             wait (no block)
             print 10220
              |
             fork----------------------------------------------------->
                                                                      |
                                                                  while(0);
                                                                  terminate;
                                                                      |
             print 10218 9948-----------------------------------------<
             wait (no block)
             print 10221
             terminate
               |
---------------<
天煞孤星 2024-12-17 08:34:56

fork 为子进程返回零,因此只有原始进程进入 while 循环;孩子们没有打印任何东西就退出了。

每次父进程打印它的进程id和它的父进程id,然后打印子进程id作为wait的返回值。

在您的示例中,原始进程的 pid = 10218,它分叉进程 ID 为 10219、10220、10221 等的子进程。

fork returns zero for the child process so only the original process enters the while loop; the children exit without printing anything.

Each time the parent prints its process id and its parent's process id and then prints the child process id as the return value of wait.

In your example the original process has pid = 10218 and it forks children with process ids 10219, 10220, 10221, etc.

奢欲 2024-12-17 08:34:56

那就完全没问题了。

如果您对 fork() 创建的进程的 PID 感兴趣,您应该打印返回值。

getpid 将始终返回主进程的 PID,而 getppid 则返回其父进程(shell)的 PI​​D。由于它们不会改变,因此没有必要在循环中打印它们。

That's perfectly ok.

If you are interested of the PID of the processes created by fork() you should print the returned value.

getpid will always return the PID of the main process, and getppid its parent's (the shell). Since they don't change it's no point to print them in the loop.

~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文