blocks|key|3993153|text|对fork()的调用既会启动一个新进程，又会继续执行旧进程。如果有某种错误，它会返回一个error值。所有错误和只有错误都是负数。这是第一个if块检查的内容。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3993154|在新进程中，fork()返回0。因此，递增v和递减g的分支仅在子进程中调用，而不是在父进程中调用。|3993155|在原始进程中，fork()函数返回子进程的进程标识符(PID)，它是一个正整数。(这将在稍后传递给waitpid()。因此，只在父进程中调用递减v和递增g的分支，而不是子进程。|3993156|每个进程都有自己的v和g副本。(这是进程和线程之间的主要区别:线程共享内存。)在现代的SMP操作系统上，子进程将获得父进程的内存映射的副本。但它们指的是相同的物理内存页面，直到一个进程或另一个进程写入它们。当发生这种情况时，将对该页内存进行复制，两个进程现在都会获得自己的、不同的副本。|3993157|按照现代Linux内核实现fork()的方式，子进程将在父进程之前继续。这对性能有很大的影响。大多数调用fork()的程序都会立即让子进程调用exec()来启动新程序。这意味着它根本不需要父内存的副本。(现在有一种更新、更简单的方法可以在新进程中启动不同的程序，即posix_spawn()。)另一方面，父进程几乎总是保持运行并修改其内存。因此，让子进程有机会声明它将丢弃继承的内存，这意味着父进程不需要担心为其子进程留下任何内存页面的未经修改的副本，内核也不必经历写时复制的繁琐过程。|3993158|但在实践中，任何像样的编译器都会将这两个局部变量都保存在寄存器中，因此不会出现这个问题。|3993159|在循环的下一次迭代中(仅在子进程终止后发生)，将使用父进程变量的更新值生成一个新子进程。每个子进程还使用从其父进程继承的相同的v和g值继续运行循环。|3993160|entityMap^0|1|6|1Y|2|0|6|6|L|1|P|1|0|7|6|1D|9|20|1|24|1|0|9|1|B|1|0|D|6|1G|6|1Z|6|3O|D|0|0|1R|1|1T|1|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|1E|8|@$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]]|D|@]|E|$]]|$1|L|3|M|5|6|7|1J|8|@$9|1K|A|1L|B|C]|$9|1M|A|1N|B|C]|$9|1O|A|1P|B|C]|$9|1Q|A|1R|B|C]]|D|@]|E|$]]|$1|N|3|O|5|6|7|1S|8|@]|D|@]|E|$]]|$1|P|3|Q|5|6|7|1T|8|@$9|1U|A|1V|B|C]|$9|1W|A|1X|B|C]]|D|@]|E|$]]|$1|R|3|-4|5|6|7|1Y|8|@]|D|@]|E|$]]]|S|$]]

The call to <code>fork()</code> both starts a new process and continues the old one. If there is some kind of error, it returns an error value. All errors and only errors are negative numbers. This is what the first <code>if</code> block checks.

In the new process, <code>fork()</code> returns 0. The branch that increments <code>v</code> and decrements <code>g</code> is therefore called only in the child process, not the parent.

In the original process, the <code>fork()</code> function returns the process identifier (PID) of the daughter process, which is a positive integer. (This will later be passed to <code>waitpid()</code>. Therefore, the branch that decrements <code>v</code> and increments <code>g</code> is only called in the parent process, not the child.

Each process has its own copy of <code>v</code> and <code>g</code>. (That’s the main difference between a process and a thread: threads share memory.) On a modern SMP operating system, what will happen is that the child process gets a copy of the parent’s memory map. but these refer to the same pages of physical memory until one process or the other writes to them. When that happens, a copy is made of that page of memory and both processes now get their own, different copies.

The way modern Linux kernels implement <code>fork()</code>, the child process will continue before the parent does. This made a significant difference to performance. Most programs that call <code>fork()</code> immediately have the child process call <code>exec()</code> to start a new program. That means it isn’t going to need its copy of the parent’s memory at all. (There is a newer, simpler way to start a different program in a new process now, <code>posix_spawn()</code>.) The parent process, on the other hand, almost always keeps running and modifying its memory. Therefore, giving the child the chance to declare that it’s going to discard the memory it inherited means that the parent doesn’t need to worry about leaving an unmodified copy of any memory pages for its children, and the kernel does not have to go through the rigmarole of copy-on-write.

In practice, though, any decent compiler will keep both local variables in registers, so this issue will not arise.

On the next iteration of the loop, which only happens after the child process terminates, a new child process is spawned using the updated values of the parent’s variables. Each child process also continues to run the loop with the same values of <code>v</code> and <code>g</code> that it inherited from its parent.

blocks|key|3993266|text|每个对fork的调用都会使用自己的变量生成自己的进程，这些变量会在调用时被复制(逻辑上，当实际复制发生时，优化可能会发生变化，但不会改变结果)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3993267|所以当你进入循环时，v递增到1，然后你分叉。此时，父进程具有g=-1，v=1，p=，而新子进程具有g=-1，v=1，p=0。然后，父进程进入else情况，将g增加到0，v增加到4，然后等待子进程完成，而子进程进入"else+if+(p+==+0)"，将v增加到2，将g减少到-2，然后再次循环。|3993268|至此，您希望已经获得了足够的信息来遵循下两个子进程的逻辑，完成循环，并打印各自的结果。当它们这样做时，第一个子进程也将使用v=6结束其等待进程，退出循环，并打印其结果。|3993269|此时，父对象将解除阻塞，再次循环(在此过程中再派生一个子对象)，然后(该子对象完成后)退出循环。|3993270|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Each call to fork generates its own process with its own variables, which are copied at the time of the call (logically; optimization may change when the actual copy happens, but not in a way that'll change the outcome).

So when you enter the loop, v gets incremented to 1, then you fork. At this point the parent process has g=-1, v=1, p= and the new child has g=-1, v=1, p=0. The parent then drops into the else case, incrementing g to 0 and v to 4 and then waiting for the child to complete, whereas the child drops into the "else if (p == 0)", increments v to 2, decrements g to -2, and goes around the loop again.

From there, you've hopefully now got enough information to follow the logic as the next two child processes get forked off, finish off the loop, and print their respective results. When they do, the first child will also come to the end of its waitpid with v=6, drop out of the loop, and print its results.

At this point, the parent will unblock, go around the loop one more time (forking off one more child along the way), and (once that child has completed) drop out of the loop.

So I have this program I'm trying to understand, its from an old exam but I just cant get a grip of it. How do I know the order of the forks and how the variables are changed? 

<pre><code>static int g = -1;

int main(int argc, char *argv[])
{
 int v = 0;
 pid_t p;

 while (v++ &lt; 6)
 if ((p = fork()) &lt; 0) {
 perror("fork error");
 return 1;
 } else if (p == 0) {
 v++;
 g--;
 } else {
 g++;
 v+=3;
 if (waitpid(p, NULL, 0) != p) {
 perror("waitpid error");
 return 1;
 }
 }
 printf("mypid = %d parentpid = %d p = %d v = %d g = %d\n",
 getpid(), getppid(), p, v, g);
 return 0;
}
</code></pre>

Understanding fork() order in C

内存映射

编译器

Linux

所以我有一个我想要理解的程序，它来自一个旧的考试，但我就是不能掌握它。我如何知道fork的顺序以及变量是如何改变的？static int g = -1;int main(int argc, char *argv[]){ int v = 0; pid_t p; while (v++ < 6) ...

问理解C中的fork()顺序
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问理解C中的fork()顺序EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问理解C中的fork()顺序
EN