blocks|key|1189202|text|在fork之后，您可以是父(fork返回子PID)，也可以是子(fork返回0)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1189203|在第一次调用fork之后，您将有两个进程:父进程(在示例中是a+=+2)和子进程(a+=+0)。|1189204|父亲(a+=+2)将给一个孩子(b+=+0)和一个新父亲(b+=+3)。孩子(a+=+0)将给一个新的孩子(b+=+0)，它将是他的父亲(b+=+4)。|1189205|您的可能输出是：|1189206|a:2,+b:3+->+father+and+father
a:2,+b:0+->+father+and+child
a:0,+b:4+->+child+and+father
a:0,+b:0+->+child+and+child|code-block|syntax|javascript|1189207|entityMap^0|1|4|E|4|W|4|12|1|0|6|4|U|5|15|5|0|3|5|G|5|T|5|13|5|1I|5|1X|5|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|11|8|@$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|18|8|@$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|1L|8|@]|D|@]|E|$]]|$1|L|3|M|5|N|7|1M|8|@]|D|@]|E|$O|P]]|$1|Q|3|-4|5|6|7|1N|8|@]|D|@]|E|$]]]|R|$]]

After a <code>fork</code>, you can be either in the father (<code>fork</code> returns the child's PID) or in the child (<code>fork</code> returns <code>0</code>).

After the first call to <code>fork</code>, you will have 2 processes: the father (<code>a = 2</code> in your example) and the child (<code>a = 0</code>).

Both will fork, the father (<code>a = 2</code>) will give a child (<code>b = 0</code>) and a new father (<code>b = 3</code>). The child (<code>a = 0</code>) will give a new child (<code>b = 0</code>) of which it will be the father (<code>b = 4</code>).

Your possible output is:

<pre><code>a:2, b:3 -&gt; father and father
a:2, b:0 -&gt; father and child
a:0, b:4 -&gt; child and father
a:0, b:0 -&gt; child and child
</code></pre>

blocks|key|861149|text|第一个叉之前的：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|861150|PID+1+(father)
a+=+(not+in+scope+yet)
b+=+(not+in+scope+yet)|code-block|syntax|javascript|861151|第一个叉子后的：|861152|PID+1+(father)
a+=+2
b+=+(not+in+scope+yet)

PID+2+(child+of+1)
a+=+0
b+=+(not+in+scope+yet)|861153|第二个叉子后的：|861154|PID+1+(father)
a+=+2
b+=+3

PID+2+(child+of+1)
a+=+0
b+=+4

PID+3+(child+of+1)
a+=+2
b+=+0

PID+4+(child+of+2)
a+=+0
b+=+0|861155|entityMap^0|7|1|0|0|7|1|0|0|7|1|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|S|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|T|$]]

Before first fork:

<pre><code>PID 1 (father)
a = (not in scope yet)
b = (not in scope yet)
</code></pre>

After first fork:

<pre><code>PID 1 (father)
a = 2
b = (not in scope yet)

PID 2 (child of 1)
a = 0
b = (not in scope yet)
</code></pre>

After second fork:

<pre><code>PID 1 (father)
a = 2
b = 3

PID 2 (child of 1)
a = 0
b = 4

PID 3 (child of 1)
a = 2
b = 0

PID 4 (child of 2)
a = 0
b = 0
</code></pre>

blocks|key|1602716|text|你知道的|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1602717|返回值是子进程中的零和父进程中子进程的id号，或者是错误时的-1。|blockquote|1602718|那么，让我们一步一步地看看这里发生了什么。|1602719|调用fork()时，它使用id+n创建一个新的子级，然后在子0和父n中返回。|offset|length|style|CODE|1602720|因此，让我们假设我们的进程是pid+1，当第一个fork()被调用时，它用pid+2创建一个进程，然后返回到一个值。a将在进程2+(子进程)中具有值2，在进程1中具有值2(父进程)。|1602721|然后，每个进程将调用fork()，并将返回值分配给父进程中的b。在子元素中，b将具有值0。|1602722|无论如何，我认为这个模式将简化理解：|1602723|主要开始：|1602724|%7C
%7C
int+a+=+fork();+//+It+creates+a+new+process,+and+the+old+one+continues+going
%7C
%7C-------------------------%7C
a+=+2;+/*+Parent+*/+++++++a+=+0;+//+Child
%7C+++++++++++++++++++++++++%7C
%7C+++++++++++++++++++++++++%7C
int+b+=+fork();+++++++++++int+b+=+fork();+//+Each+one+create+a+new+process
%7C+++++++++++++++++++++++++%7C
%7C+++++++++++++++++++++++++%7C-----------------------------%7C
%7C+++++++++++++++++++++++++/*+Child+->+Parent+*/+++++++++//+Child+->+Child
%7C+++++++++++++++++++++++++a+=+0;+b+=+4;+++++++++++++++++a+=+0;+b+=+0
%7C
%7C
%7C
%7C
%7C-----------------------------%7C
/*+Parent+->+Parent+*/++++++++//+Parent+->+Child
a+=+2;+b+=+3;+++++++++++++++++a+=+2,+b+=+0;+|code-block|syntax|javascript|1602725|entityMap^0|0|0|0|2|6|G|1|U|1|X|1|0|I|1|O|6|15|1|1M|1|1R|1|22|1|27|1|2C|1|0|A|6|U|1|12|1|17|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|12|8|@]|9|@]|A|$]]|$1|E|3|F|5|6|7|13|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|14|8|@$I|15|J|16|K|L]|$I|17|J|18|K|L]|$I|19|J|1A|K|L]|$I|1B|J|1C|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|1D|8|@$I|1E|J|1F|K|L]|$I|1G|J|1H|K|L]|$I|1I|J|1J|K|L]|$I|1K|J|1L|K|L]|$I|1M|J|1N|K|L]|$I|1O|J|1P|K|L]|$I|1Q|J|1R|K|L]|$I|1S|J|1T|K|L]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1U|8|@$I|1V|J|1W|K|L]|$I|1X|J|1Y|K|L]|$I|1Z|J|20|K|L]|$I|21|J|22|K|L]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|23|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|24|8|@]|9|@]|A|$]]|$1|U|3|V|5|W|7|25|8|@]|9|@]|A|$X|Y]]|$1|Z|3|-4|5|6|7|26|8|@]|9|@]|A|$]]]|10|$]]

You know that

<blockquote>
 The return value is the zero in the child and the process-id number of the child in the parent, or -1 upon error.
</blockquote>

So, let's see step by step what's happening here.

When <code>fork()</code> is called, it creates a new child with id <code>n</code>, then returns in the child <code>0</code> and in the parent <code>n</code>.

So let's suppose our process as pid <code>1</code>, when the first <code>fork()</code> is called it creates a process with pid <code>2</code>, then returns to a a value. <code>a</code> will have value <code>0</code> in the process <code>2</code> (the child), and will have value <code>2</code> in process <code>1</code> (the parent).

Then each process will call <code>fork()</code> and assign the return value to <code>b</code> in the parent process. In the child, <code>b</code> will have value <code>0</code>.

Anyway, I think this schema will simplify the comprehension:

The main starts:

<pre><code>|
|
int a = fork(); // It creates a new process, and the old one continues going
|
|-------------------------|
a = 2; /* Parent */ a = 0; // Child
| |
| |
int b = fork(); int b = fork(); // Each one create a new process
| |
| |-----------------------------|
| /* Child -&gt; Parent */ // Child -&gt; Child
| a = 0; b = 4; a = 0; b = 0
|
|
|
|
|-----------------------------|
/* Parent -&gt; Parent */ // Parent -&gt; Child
a = 2; b = 3; a = 2, b = 0; 
</code></pre>

blocks|key|861170|text|我甚至不想回答你的问题。更多的是关于显示通常使用的模式。如果注释中有适当的代码格式，它可能是一个注释。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|861171|使用fork()的基本结构是：|offset|length|style|CODE|861172|if+(int+PID+=+fork()+==+0+)+{
++++//it's+a+child+process
}+else+{
++++//it's+a+parent+process
}|code-block|syntax|javascript|861173|使用简单|861174|int+PID1+=+fork();
int+PID2+=+fork();|861175|是非常危险的，因为你几乎肯定会收到Race+condition。|861176|entityMap^0|0|2|6|0|0|0|0|H|E|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@$D|W|E|X|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|Y|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|11|8|@$D|12|E|13|F|G]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|T|$]]

I'm not even trying to answer your question. It's more about showing the pattern which is commonly used. It might have been a comment if only there was proper code formatting in comments.

The basic construction with <code>fork()</code> is:

<pre><code>if (int PID = fork() == 0 ) {
 //it's a child process
} else {
 //it's a parent process
}
</code></pre>

Using simple

<pre><code>int PID1 = fork();
int PID2 = fork();
</code></pre>

is very risky as you will almost for sure receive <code>Race condition</code>.

blocks|key|1189311|text|Original+process:
forks+child+A,+and+child+B
prints+`a:2,+b:3`

++++child+A+process:
++++forks+child+BB
++++prints+`a:0,+b:4`

++++++++child+BB+proess:
++++++++forks+nothing
++++++++prints+`a:0,+b:0`

++++child+B+process:
++++forks+nothing
++++prints+`a:2,+b:0`|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1189312|而且，由于您没有使用任何wait或waitpid，所以它们可以以任何顺序出现。|unstyled|offset|length|style|CODE|1189313|entityMap^0|0|C|4|H|7|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@$G|O|H|P|I|J]|$G|Q|H|R|I|J]]|9|@]|A|$]]|$1|K|3|-4|5|F|7|S|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>Original process:
forks child A, and child B
prints `a:2, b:3`

 child A process:
 forks child BB
 prints `a:0, b:4`

 child BB proess:
 forks nothing
 prints `a:0, b:0`

 child B process:
 forks nothing
 prints `a:2, b:0`
</code></pre>

And since you have not use any <code>wait</code> or <code>waitpid</code> these can appear in any order.

Let's assume that there is a process with <code>PID = 1</code> and it runs the following code:

<pre><code>int a = fork();
int b = fork();
printf(“a: %d, b: %d\n”, a, b); 
</code></pre>

Let's further assume that new <code>PID</code>s will be given one by one, so the second given <code>PID</code> will be <code>2</code>, then <code>3</code> etc.

A possible output is:

<pre><code>a:2, b:3
a:2, b:0
a:0, b:4
a:0, b:0
</code></pre>

I'm having some troubles trying to understand the output of the above code, e especially why <code>a:0, b:4</code> and <code>a:2, b:3</code>.

Trouble understanding fork() output

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

让我们假设有一个使用PID = 1的进程，它运行以下代码：int a = fork();int b = fork();printf(“a: %d, b: %d\n”, a, b); 让我们进一步假设新的PID将一个接一个地给出，所以第二个给定的PID将是2，然后是3等等。一项可能的产出是：a:2, b:3a:2, b:...

问理解fork()输出的问题
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问理解fork()输出的问题EN