blocks|key|1317039|text|fork()是Unix创建新进程的方式。在调用fork()时，您的进程被克隆，两个不同的进程从那里继续执行。其中之一，即孩子，将使fork()返回0。另一个是父进程，它让fork()返回子进程的PID+(进程ID)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1317040|例如，如果您在shell中键入以下内容，shell程序将调用fork()，然后执行您在子进程中传递的命令(在本例中为telnetd)，而父进程将再次显示提示，以及一条指示后台进程的PID的消息。|1317041|$+telnetd+&|code-block|syntax|javascript|1317042|至于创建新进程的原因，这就是你的操作系统可以同时做很多事情的原因。这就是为什么你可以运行一个程序，当它运行时，切换到另一个窗口并做其他事情。|1317043|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

fork() is how Unix create new processes. At the point you called fork(), your process is cloned, and two different processes continue the execution from there. One of them, the child, will have fork() return 0. The other, the parent, will have fork() return the PID (process ID) of the child.

For example, if you type the following in a shell, the shell program will call fork(), and then execute the command you passed (telnetd, in this case) in the child, while the parent will display the prompt again, as well as a message indicating the PID of the background process.

<pre><code>$ telnetd &amp;
</code></pre>

As for the reason you create new processes, that's how your operating system can do many things at the same time. It's why you can run a program and, while it is running, switch to another window and do something else.

blocks|key|1532283|text|fork()用于创建子进程。当调用fork()函数时，将产生一个新进程，并且fork()函数调用将为子进程和父进程返回不同的值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1532284|如果返回值为0，您就知道自己是子进程，如果返回值是一个数字(恰好是子进程id)，您就知道自己是父进程。(如果它是负数，则fork失败，并且没有创建子进程)|1532285|http://www.yolinux.com/TUTORIALS/ForkExecProcesses.html|offset|length|1532286|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|1J|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@$F|R|G|S|1|T]]|A|$]]|$1|H|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|E]]]]

fork() is used to create child process. When a fork() function is called, a new process will be spawned and the fork() function call will return a different value for the child and the parent. 

If the return value is 0, you know you're the child process and if the return value is a number (which happens to be the child process id), you know you're the parent. (and if it's a negative number, the fork was failed and no child process was created)

<a href="http://www.yolinux.com/TUTORIALS/ForkExecProcesses.html" rel="noreferrer">http://www.yolinux.com/TUTORIALS/ForkExecProcesses.html</a>

blocks|key|1317325|text|fork()主要用于为调用此函数的进程创建子进程。无论何时调用fork()，它都会为子id返回一个零。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1317326|pid=fork()
if+pid==0
//this+is+the+child+process
else+if+pid!=0
//this+is+the+parent+process|code-block|syntax|javascript|1317327|这样，您就可以为父对象和子对象提供不同的操作，并利用多线程特性。|1317328|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

fork() is basically used to create a child process for the process in which you are calling this function. Whenever you call a fork(), it returns a zero for the child id. 

<pre><code>pid=fork()
if pid==0
//this is the child process
else if pid!=0
//this is the parent process
</code></pre>

by this you can provide different actions for the parent and the child and make use of multithreading feature.

blocks|key|1316977|text|fork()将创建一个与父进程相同的新子进程。因此，之后在代码中运行的所有内容都将由两个进程运行-例如，如果您有一台服务器，并且您想要处理多个请求，这将非常有用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1316978|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

fork() will create a new child process identical to the parent. So everything you run in the code after that will be run by both processes — very useful if you have for instance a server, and you want to handle multiple requests.

blocks|key|1532835|text|系统调用fork()用于创建进程。fork()的目的是创建一个新的进程，它将成为调用者的子进程。创建新的子进程后，两个进程都将执行fork()系统调用之后的下一条指令。因此，我们必须区分父母和孩子。这可以通过测试fork()的返回值来实现：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1532836|如果fork()返回负值，则创建子进程失败。fork()向新创建的子进程返回一个零。fork()向父进程返回一个正值，即子进程的进程ID。返回的进程ID类型为sys/types.h中定义的pid_t类型。正常情况下，进程ID是一个整数。此外，进程可以使用函数getpid()来检索分配给该进程的进程ID。因此，在系统调用fork()之后，一个简单的测试就可以知道哪个进程是子进程。请注意，Unix将精确复制父进程的地址空间并将其提供给子进程。因此，父进程和子进程具有单独的地址空间。|1532837|让我们通过一个例子来理解它，以明确以上几点。此示例不区分父进程和子进程。|1532838|#include++<stdio.h>
#include++<string.h>
#include++<sys/types.h>

#define+++MAX_COUNT++200
#define+++BUF_SIZE+++100

void++main(void)
{
+++++pid_t++pid;
+++++int++++i;
+++++char+++buf[BUF_SIZE];

+++++fork();
+++++pid+=+getpid();
+++++for+(i+=+1;+i+<=+MAX_COUNT;+i%2B%2B)+{
++++++++++sprintf(buf,+"This+line+is+from+pid+%25d,+value+=+%25d\n",+pid,+i);
++++++++++write(1,+buf,+strlen(buf));
+++++}+
}|code-block|syntax|javascript|1532839|假设上面的程序一直执行到调用fork()时为止。|1532840|如果对fork()的调用执行成功，Unix将创建两个相同的地址空间副本，一个用于父地址空间，另一个用于子地址空间。这两个进程都将从fork()调用之后的下一条语句开始执行。在这种情况下，两个进程都将在赋值时开始执行|1532841|pid+=+.....;|1532842|这两个进程都在系统调用fork()之后立即开始执行。由于两个进程具有相同但不同的地址空间，因此在fork()调用之前初始化的那些变量在两个地址空间中具有相同的值。由于每个进程都有自己的地址空间，因此任何修改都将独立于其他进程。换句话说，如果父进程更改了其变量的值，则修改只会影响父进程地址空间中的变量。fork()调用创建的其他地址空间不会受到影响，即使它们具有相同的变量名。|1532843|使用write而不是printf的原因是什么？这是因为printf()是“缓冲的”，这意味着printf()会将进程的输出组合在一起。在缓冲父进程的输出时，子进程还可以使用printf打印出一些信息，这些信息也将被缓冲。因此，由于输出不会立即发送到屏幕，因此您可能无法获得预期结果的正确顺序。更糟糕的是，这两个过程的输出可能以奇怪的方式混合在一起。为了克服这个问题，您可以考虑使用“无缓冲”写入。|1532844|如果您运行此程序，您可能会在屏幕上看到以下内容：|1532845|................
This+line+is+from+pid+3456,+value+13
This+line+is+from+pid+3456,+value+14
+++++................
This+line+is+from+pid+3456,+value+20
This+line+is+from+pid+4617,+value+100
This+line+is+from+pid+4617,+value+101
+++++................
This+line+is+from+pid+3456,+value+21
This+line+is+from+pid+3456,+value+22
+++++................|1532846|进程ID+3456可以是分配给父进程或子进程的进程ID。由于这些进程是并发运行的，它们的输出线以一种相当不可预测的方式混合在一起。此外，这些线路的顺序由CPU调度器确定。因此，如果你再次运行这个程序，你可能会得到一个完全不同的结果。|1532847|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|14|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|15|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|16|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|17|8|@]|9|@]|A|$]]|$1|O|3|P|5|H|7|18|8|@]|9|@]|A|$I|J]]|$1|Q|3|R|5|6|7|19|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1A|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1B|8|@]|9|@]|A|$]]|$1|W|3|X|5|H|7|1C|8|@]|9|@]|A|$I|J]]|$1|Y|3|Z|5|6|7|1D|8|@]|9|@]|A|$]]|$1|10|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|11|$]]

System call fork() is used to create processes. It takes no arguments and returns a process ID. The purpose of fork() is to create a new process, which becomes the child process of the caller. After a new child process is created, both processes will execute the next instruction following the fork() system call. Therefore, we have to distinguish the parent from the child. This can be done by testing the returned value of fork():

If fork() returns a negative value, the creation of a child process was unsuccessful.
fork() returns a zero to the newly created child process.
fork() returns a positive value, the process ID of the child process, to the parent. The returned process ID is of type pid_t defined in sys/types.h. Normally, the process ID is an integer. Moreover, a process can use function getpid() to retrieve the process ID assigned to this process.
Therefore, after the system call to fork(), a simple test can tell which process is the child. Please note that Unix will make an exact copy of the parent's address space and give it to the child. Therefore, the parent and child processes have separate address spaces.

Let us understand it with an example to make the above points clear. This example does not distinguish parent and the child processes. 

<pre><code>#include &lt;stdio.h&gt;
#include &lt;string.h&gt;
#include &lt;sys/types.h&gt;

#define MAX_COUNT 200
#define BUF_SIZE 100

void main(void)
{
 pid_t pid;
 int i;
 char buf[BUF_SIZE];

 fork();
 pid = getpid();
 for (i = 1; i &lt;= MAX_COUNT; i++) {
 sprintf(buf, "This line is from pid %d, value = %d\n", pid, i);
 write(1, buf, strlen(buf));
 } 
}
</code></pre>

Suppose the above program executes up to the point of the call to fork().

If the call to fork() is executed successfully, Unix will make two identical copies of address spaces, one for the parent and the other for the child.
Both processes will start their execution at the next statement following the fork() call. In this case, both processes will start their execution at the assignment 

<pre><code>pid = .....;
</code></pre>

Both processes start their execution right after the system call fork(). Since both processes have identical but separate address spaces, those variables initialized before the fork() call have the same values in both address spaces. Since every process has its own address space, any modifications will be independent of the others. In other words, if the parent changes the value of its variable, the modification will only affect the variable in the parent process's address space. Other address spaces created by fork() calls will not be affected even though they have identical variable names.

What is the reason of using write rather than printf? It is because printf() is "buffered," meaning printf() will group the output of a process together. While buffering the output for the parent process, the child may also use printf to print out some information, which will also be buffered. As a result, since the output will not be send to screen immediately, you may not get the right order of the expected result. Worse, the output from the two processes may be mixed in strange ways. To overcome this problem, you may consider to use the "unbuffered" write.

If you run this program, you might see the following on the screen:

<pre><code>................
This line is from pid 3456, value 13
This line is from pid 3456, value 14
 ................
This line is from pid 3456, value 20
This line is from pid 4617, value 100
This line is from pid 4617, value 101
 ................
This line is from pid 3456, value 21
This line is from pid 3456, value 22
 ................
</code></pre>

Process ID 3456 may be the one assigned to the parent or the child. Due to the fact that these processes are run concurrently, their output lines are intermixed in a rather unpredictable way. Moreover, the order of these lines are determined by the CPU scheduler. Hence, if you run this program again, you may get a totally different result.

blocks|key|1317388|text|如果您正在编写应用程序，则可能不需要在日常编程中使用fork。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1317389|即使您确实希望您的程序启动另一个程序来执行某些任务，还有其他在幕后使用fork的更简单的接口，例如C和perl中的"system“。|1317390|例如，如果您希望您的应用程序启动另一个程序(如bc+)来为您执行一些计算，您可以使用'system‘来运行它。系统执行一个'fork‘来创建一个新进程，然后执行一个'exec’来将该进程转换为bc。一旦bc完成，系统就会将控制权返回给您的程序。|1317391|您也可以异步运行其他程序，但我记不清是如何运行的。|1317392|如果您正在编写服务器、shell、病毒或操作系统，您可能更希望使用fork。|1317393|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

You probably don't need to use fork in day-to-day programming if you are writing applications.

Even if you do want your program to start another program to do some task, there are other simpler interfaces which use fork behind the scenes, such as "system" in C and perl.

For example, if you wanted your application to launch another program such as bc to do some calculation for you, you might use 'system' to run it. System does a 'fork' to create a new process, then an 'exec' to turn that process into bc. Once bc completes, system returns control to your program.

You can also run other programs asynchronously, but I can't remember how.

If you are writing servers, shells, viruses or operating systems, you are more likely to want to use fork.

blocks|key|1532648|text|Fork创建新的进程。如果没有fork，你的unix系统只能运行init。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1532649|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Fork creates new processes. Without fork you would have a unix system that could only run init.

blocks|key|1532415|text|多处理是计算的核心。例如，您的IE或Firefox可以创建一个进程，以便在您仍在浏览internet时为您下载文件。或者，当您在文字处理器中打印出文档时，您仍然可以查看不同的页面，并对其进行一些编辑。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1532416|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Multiprocessing is central to computing. For example, your IE or Firefox can create a process to download a file for you while you are still browsing the internet. Or, while you are printing out a document in a word processor, you can still look at different pages and still do some editing with it.

blocks|key|1532702|text|Fork()用于创建每个主体编写的新进程。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1532703|下面是以二进制形式创建进程的代码，tree.......It将要求扫描您希望在二叉树中创建的进程的层数|1532704|#include<unistd.h>+
#include<fcntl.h>+
#include<stdlib.h>+++
int+main()+
{
int+t1,t2,p,i,n,ab;
p=getpid();++++++++++++++++
printf("enter+the+number+of+levels\n");fflush(stdout);
scanf("%25d",&n);++++++++++++++++
printf("root+%25d\n",p);fflush(stdout);
for(i=1;i<n;i%2B%2B)++++
{++++++++
++++t1=fork();

++++if(t1!=0)
++++++++t2=fork();++++++++
++++if(t1!=0+&&+t2!=0)++++++++
++++++++break;++++++++++++
++++printf("child+pid+%25d+++parent+pid+%25d\n",getpid(),getppid());fflush(stdout);
}+++
++++waitpid(t1,&ab,0);
++++waitpid(t2,&ab,0);
return+0;
}|code-block|syntax|javascript|1532705|输出|1532706|++enter+the+number+of+levels
++3
++root+20665
++child+pid+20670+++parent+pid+20665
++child+pid+20669+++parent+pid+20665
++child+pid+20672+++parent+pid+20670
++child+pid+20671+++parent+pid+20670
++child+pid+20674+++parent+pid+20669
++child+pid+20673+++parent+pid+20669|1532707|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Fork() is used to create new processes as every body has written.

Here is my code that creates processes in the form of binary tree.......It will ask to scan the number of levels upto which you want to create processes in binary tree

<pre><code>#include&lt;unistd.h&gt; 
#include&lt;fcntl.h&gt; 
#include&lt;stdlib.h&gt; 
int main() 
{
int t1,t2,p,i,n,ab;
p=getpid(); 
printf("enter the number of levels\n");fflush(stdout);
scanf("%d",&amp;n); 
printf("root %d\n",p);fflush(stdout);
for(i=1;i&lt;n;i++) 
{ 
 t1=fork();

 if(t1!=0)
 t2=fork(); 
 if(t1!=0 &amp;&amp; t2!=0) 
 break; 
 printf("child pid %d parent pid %d\n",getpid(),getppid());fflush(stdout);
} 
 waitpid(t1,&amp;ab,0);
 waitpid(t2,&amp;ab,0);
return 0;
}
</code></pre>

OUTPUT

<pre><code> enter the number of levels
 3
 root 20665
 child pid 20670 parent pid 20665
 child pid 20669 parent pid 20665
 child pid 20672 parent pid 20670
 child pid 20671 parent pid 20670
 child pid 20674 parent pid 20669
 child pid 20673 parent pid 20669
</code></pre>

blocks|key|1317202|text|fork()用于派生一个子进程。通常，它与线程在类似的情况下使用，但有区别。与线程不同，fork()创建了完整的独立进程，这意味着在fork()被调用时，子进程和父进程是彼此的直接副本，它们是完全独立的，两者都不能访问对方的内存空间(而不会遇到访问另一个程序内存的正常麻烦)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1317203|一些服务器应用程序仍在使用fork()，主要是那些在处理用户请求之前删除权限的*NIX机器上以根用户身份运行的应用程序。还有一些其他的用例，但现在大多数人已经转向多线程了。|1317204|entityMap^0|0|6|18|6|1U|6|0|D|6|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|I|$]]

<code>fork()</code> is used to spawn a child process. Typically it's used in similar sorts of situations as threading, but there are differences. Unlike threads, <code>fork()</code> creates whole seperate processes, which means that the child and the parent while they are direct copies of each other at the point that <code>fork()</code> is called, they are completely seperate, neither can access the other's memory space (without going to the normal troubles you go to access another program's memory).

<code>fork()</code> is still used by some server applications, mostly ones that run as root on a *NIX machine that drop permissions before processing user requests. There are some other usecases still, but mostly people have moved to multithreading now.

blocks|key|1317799|text|an+answer+to+a+similar+question+on+the+unix+stack+exchange中解释了fork()与仅仅使用exec()函数来启动新进程之间的关系。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1317800|本质上，由于fork复制了当前进程，因此默认情况下会为进程建立所有可能的选项，因此程序员不必提供这些选项。|1317801|相比之下，在Windows操作系统中，程序员必须使用CreateProcess函数，该函数要复杂得多，并且需要填充各种各样的结构来定义新进程的参数。|1317802|因此，总而言之，使用forking+(而不是exec‘in+)的原因是创建新进程的简单性。|1317803|entityMap|0|LINK|mutability|MUTABLE|url|https://unix.stackexchange.com/questions/31118/why-is-the-default-process-creation-mechanism-fork^0|0|1M|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@$A|S|B|T|1|U]]|C|$]]|$1|D|3|E|5|6|7|V|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@]|C|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|K|$L|$5|M|N|O|C|$P|Q]]]]

The rationale behind fork() versus just having an exec() function to initiate a new process is explained in <a href="https://unix.stackexchange.com/questions/31118/why-is-the-default-process-creation-mechanism-fork">an answer to a similar question on the unix stack exchange</a>.

Essentially, since fork copies the current process, all of the various possible options for a process are established by default, so the programmer does not have supply them.

In the Windows operating system, by contrast, programmers have to use the CreateProcess function which is MUCH more complicated and requires populating a multifarious structure to define the parameters of the new process.

So, to sum up, the reason for forking (versus exec'ing) is simplicity in creating new processes.

blocks|key|1532906|text|Fork()系统调用用于创建子进程。它完全是父进程的副本。Fork从父级复制堆栈部分、堆部分、数据部分、环境变量和命令行参数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1532907|参考：http://man7.org/linux/man-pages/man2/fork.2.html|offset|length|1532908|entityMap|0|LINK|mutability|MUTABLE|url|http://man7.org/linux/man-pages/man2/fork.2.html^0|0|3|1C|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

Fork() system call use to create a child process. It is exact duplicate of parent process. Fork copies stack section, heap section, data section, environment variable, command line arguments from parent.

refer: <a href="http://man7.org/linux/man-pages/man2/fork.2.html" rel="nofollow noreferrer">http://man7.org/linux/man-pages/man2/fork.2.html</a>

blocks|key|1533131|text|创建Fork()的目的是为了创建另一个进程，将内存状态的副本共享给父进程。它的工作方式是因为它是在以前缺乏此功能的时间切片大型机系统中获得良好线程功能的最小可能的更改。此外，程序只需要很少的修改就可以变成多进程，fork()可以简单地添加到适当的位置，这是相当优雅的。基本上，fork()是阻力最小的路径。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1533132|最初，它实际上必须复制整个父进程的内存空间。随着虚拟内存的出现，它已经被黑客攻击并被更改为更高效，写入时复制机制避免了实际复制任何内存的需要。|1533133|然而，现代系统现在允许创建实际的线程，这些线程只是共享父进程的实际堆。在现代多线程编程范式和更高级的语言中，fork()是否提供任何真正的好处是值得怀疑的，因为fork()实际上阻止进程通过内存直接通信，并迫使它们使用较慢的消息传递机制。|1533134|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Fork() was created as a way to create another process with shared a copy of memory state to the parent. It works the way it does because it was the most minimal change possible to get good threading capabilities in time-slicing mainframe systems that previously lacked this capability. Additionally, programs needed remarkably little modification to become multi-process, fork() could simply be added in the appropriate locations, which is rather elegant. Basically, fork() was the path of least resistance.
Originally it actually had to copy the entire parent process' memory space. With the advent of virtual memory, it has been hacked and changed to be more efficient, with copy-on-write mechanisms avoiding the need to actual copy any memory.
However, modern systems now allow the creation of actual threads, which simply share the parent process' actual heap. With modern multi-threading programming paradigms and more advanced languages, it's questionable whether fork() provides any real benefit, since fork() actually prevents processes from communicating through memory directly, and forces them to use slower message passing mechanisms.

In many programs and man pages of Linux, I have seen code using <code>fork()</code>. Why do we need to use <code>fork()</code> and what is its purpose?

What is the purpose of fork()?

服务器

Windows

Linux

Unix

在Linux的许多程序和手册页中，我都看到过使用fork()的代码。为什么我们需要使用fork()？它的用途是什么？

问fork()的用途是什么？
EN

回答 13

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问fork()的用途是什么？EN

回答 13

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问fork()的用途是什么？
EN