fork，vfork，clone都是linux系统调用，这三个函数分别调用sys_fork，sys_vfork，sys_clone，最终都会调用到do_fork函数。差别就在于参数的传递和一些准备工作的不同，上一章节已经详细学习了fork的流程，本章主要专注学习这三个接口函数的使用方法和差异点。

1 进程的四要素

linux进程所必须的四个要素：

• 程序代码，有一段程序供其执行： 代码不一定是进程专有，可以与其它进程共享
• 有自己专用系统堆栈空间：
• 有进程控制块(task_struct)：
• 有独立的存储空间：

以上4条，缺一不可。如果缺少第四条，那么就称其为"线程"。如果完全没有用户空间，称其位”内核线程“；如果共享用户空间，则称其为”用户线程"。

2 fork

系统调用fork，允许父进程创建一个新的进程(子进程)。新的子进程是父进程的翻版：完全继承父进程的栈、数据段、堆和执行文本的拷贝。其接口如下：

    NAME
           fork - create a child process
    
    SYNOPSIS
           #include <sys/types.h>
           #include <unistd.h>
    
           pid_t fork(void);

完成对其调用后将存在两个进程，且每个进程都会从fork的返回处继续执行。这两个进程将执行相同的程序文本段，但却各自拥有不同的栈段、数据段以及堆段拷贝。子进程的栈、数据以及栈段开始时是对父进程内存相应各部分的完全复制。执行fork之后，每个进程均可修改各自的栈数据以及堆中的变量而不影响另一进程。

为调用进程创建一个一模一样的新进程 ，但父子进程需要改变时候，执行一个copy，但是任何修改都造成分裂，如：chroot, open, 写memory，mmap，sigaction….

fork的示例

考虑以下代码的输出，假设test.txt中的内容”abcdefghijklmnopqrst…”

    #include <stdio.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <unistd.h>
    #include<fcntl.h>
    
    int main(void)
    {
            char str[10];
            int count = 1;
            int fd = open("test.txt", O_RDWR);
            if(fork() == 0)
            {
                    int cnt = read(fd, str, 10);
                    printf("Child process : %s\n", (char *)str);
                    printf("This is son, his count is: %d (%p). and his pid is: %d\n", ++count, &count, getpid());
            }
            else
            {
                    int cnt = read(fd, str, 10);
                    printf("Child process : %s\n", (char *)str);
                    printf("This is father, his count is: %d (%p), his pid is: %d\n", count, &count, getpid());
            }
    
        return 0;
    }

输出为：

• 从结果来看，子进程和父进程的PID不同，内存资源count是值的复制，子进程改变了count的值，而父进程中的count的值没有改变，这个过程请参考之前章节的写时复制技术。

• 两个进程共享了同一个指向文件的结构体，所以当子进程输出“abcdefghij”后，父进程就接着输出"klmnopqrst"

  

3 vfork

vfork也是创建子进程，但是子进程共享父进程的空间。在vfork创建子进程之后，父进程阻塞，直到子进程执行exec()或者exit()。vfork设计的最初是因为fork没有实现COW机制，很多情况下fork之后会紧跟着exec，而exec的执行相当于前面fork复制的空间全部变得无用，所以设计了vfork。而现在fork使用了COW，唯一的代价仅仅是复制父进程页表的代价，所以vfork的功能就变得越来越不重要。

    NAME
           vfork - create a child process and block parent
    
    SYNOPSIS
           #include <sys/types.h>
           #include <unistd.h>
    
           pid_t vfork(void);

vfork因为如下两个特性而更具效率，也是区别与fork所在：

• 无需为子进程复制虚拟内存页或页表，相反，子进程共享父进程的内存，直至其成功执行exec或调用exit退出

• 在子进程调用exit或exec之前，将暂停执行父进程，所以在使用vfork时，一般立即在vfork之后调用exec，如果exec调用失败，子进程应调用exit退出。

  

vfork示例

    #include <stdio.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <unistd.h>
    
    
    int main(void)
    {
    	int count =1;
    	int child;
    
    	printf("Before create son, the father's count is %d\n",count);
    	if(!(child = vfork()))
    	{
    		int i = 0;
    		for( i = 0; i< 3; i++)
    		{
    			count++;
    			printf("This is son This i is: %d count: %d\n", i, count);
    			if(i == 2)
    			{
    				printf("This is son This pid is: %d count: %d\n", getpid(), count);	
    				exit(1);
    			}
    		}
    	}
    	else
    	{
    		printf("This is father This pid is: %d count: %d\n", getpid(), count); 
    	}
        return 0;
    }

输出：

• 用vfork创建的子进程与父进程共享地址空间，也就是说子进程完全运行在父进程的地址空间上，如果这时子进程修改了某个变量，这将影响到父进程
• 子进程在vfork()返回后直接运行在父进程的栈空间，并使用父进程的内存和数据。这意味着子进程可能破坏父进程的数据结构或栈，造成失败。为了避免这些问题，需要确保一旦调用vfork()，子进程就不从当前的栈框架中返回，并且如果子进程改变了父进程的数据结构就不能调用exit函数。子进程还必须避免改变全局数据结构或全局变量中的任何信息，因为这些改变都有可能使父进程不能继续。
• 值得注意的是用vfork创建的子进程必须显示调用exit()来结束，否则子进程将不能结束，父进程就讲一直阻塞，出现异常

大家可以实际将上述例子中exit(1)这个注释掉后，会出现什么情况。对于Vfork和fork是类似的，除了下面两点：
1、阻塞父进程
2、不复制父进程的页表

之所以vfork要阻塞父进程是因为vfork后父子进程使用的是完全相同的mm_struct，也就是由完全相同的虚拟地址空间，包括栈也相同，所以两个进程就不能同时运行，否则栈就会乱掉。所以vfork后，父进程是阻塞的，直到调用了exec系列或者exit后，这个时候，子进程的mm需要释放，不再与父进程公用，这个时候就可以解除父进程的阻塞状态。

4 clone

clone是Linux为创建线程设计的，所以可以说clone是fork的升级版本，不仅可以创建进程或线程，还可以指定创建新的命名空间，有选择的继承父进程的内存、甚至可以将创建出来的进程编程父进程的兄弟进程等。

clone函数功能强大，待有很多参数，提供了一个非诚灵活自由的常见进程的方法，因此它创建进程要比前面两种方法更为复杂。clone可以有选择继承父进程的资源，你可以选择像vfork一样和父进程共享一个虚拟存储空间，也可以不和父进程共享，甚至可以选择创造出来的进程和父进程不再是父子关系，而是兄弟关系。

    NAME
           clone, __clone2 - create a child process
    
    SYNOPSIS
           /* Prototype for the glibc wrapper function */
    
           #define _GNU_SOURCE
           #include <sched.h>
    
           int clone(int (*fn)(void *), void *child_stack,
                     int flags, void *arg, ...
                     /* pid_t *ptid, void *newtls, pid_t *ctid */ );

下面是flaga可以取得值

    #define _GNU_SOURCE
    #include <sys/wait.h>
    #include <sys/utsname.h>
    #include <sched.h>
    #include <string.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <unistd.h>
    #include <pthread.h>
    #include <sched.h>
    #define FIBER_STACK 8192
    
    int a;
    void *stack;
    
    int do_something()
    {
    	a = 10;
    	printf("This is son, the pid is: %d, the a is: %d\n",getpid(), a);
    	free(stack);
    	exit(1);
    }
    
    int main(void)
    {
    	void *stack;
    	a = 1;
    	stack = malloc(FIBER_STACK);
    	if(!stack)
    	{
    		printf("The stack failed\n");
    		exit(0);
    	}
    
    	printf("Create son thread \n");
    	clone(&do_something, (char *)stack + FIBER_STACK, CLONE_VM | CLONE_VFORK, 0);
    	printf("This is father, the pid is: %d, the a is: %d\n",getpid(), a);
        return 0;
    }

输出结果：

inux创建线程的API，本质上去调 clone。要求把P2的所有资源的指针，都指向P1。线程，也被称为 Light weight process。而Linux在clone线程时也十分灵活，可以选择共享/不共享部分资源。

POSIX标准要求，进程里面如果有多个线程，在用户空间 getpid() 看到的都是同一个id，这个id其实是TGID。一个进程里面创建了多个线程，在/proc 下 的是 tgid，/proc/tgid/task/{pidx,y,z}pthread_self() 看到的是用户空间pthread线程库里获得的id 。

5. 总结

下面是三个接口的优缺点对比