进程的创建fork vs vfork

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
 
int main()
{
   pid_t pid = fork();
 
   if(pid == -1){
       printf("create child process failed!\n");
       return -1;
   }else if(pid == 0){
       printf("This is child process!\n");
   }else{
       printf("This is parent process!\n");
       printf("parent process pid = %d\n",getpid());
       printf("child process pid = %d\n",pid);
   }
 
   getchar();
 
   return 0;
}

root@ubuntu:zhuxl$ ./a.out
This is parent process!
parent process pid = 91985
child process pid = 91986
This is child process!

ps -ef 命令可以看进程的
UID         PID   PPID  C STIME TTY          TIME CMD
root       91985  90968  0 00:02 pts/0    00:00:00 ./a.out
root       91986  91985  0 00:02 pts/0    00:00:00 ./a.out

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
 
int data=10;
 
int main()
{
  pid_t pid = fork();
 
  if(pid == -1){
      printf("create child process failed!\n");
      return -1;
  }else if(pid == 0){
      printf("This is child process, data=%d!\n",data);
      data =90;
      printf("After child process modify data =%d\n",data);
  }else{
      printf("This is parent process=%d!\n",data);
  }  
 
  getchar();
  return 0;
}

root@ubuntu:zhuxl$ ./a.out
This is parent process=10!
This is child process, data=10!
After child process modify data =90

The child process is an exact duplicate of the parent process except for the following points:
 
       *  The child has its own unique process ID, and this PID does not match the ID of any existing process group (setpgid(2)) or session.
 
       *  The child's parent process ID is the same as the parent's process ID.
 
       *  The child does not inherit its parent's memory locks (mlock(2), mlockall(2)).
 
       *  Process resource utilizations (getrusage(2)) and CPU time counters (times(2)) are reset to zero in the child.
 
       *  The child's set of pending signals is initially empty (sigpending(2)).
 
      等等

Under Linux, fork() is implemented using copy-on-write pages, so the only penalty that it incurs is the time  and  memory  required  to
      duplicate the parent's page tables, and to create a unique task structure for the child.
 
  C library/kernel differences
      Since  version  2.3.3,  rather  than invoking the kernel's fork() system call, the glibc fork() wrapper that is provided as part of the
      NPTL threading implementation invokes clone(2) with flags that provide the same effect as the traditional  system  call.   (A  call  to
      fork()  is  equivalent  to a call to clone(2) specifying flags as just SIGCHLD.)  The glibc wrapper invokes any fork handlers that have
      been established using pthread_atfork(3).

#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
 
int data=10;
 
int main()
{
    pid_t pid = vfork();
 
    if(pid == -1){
        printf("create child process failed!\n");
        return -1;
    }else if(pid == 0){
        printf("This is child process, data=%d!\n",data);
        data =90;
        printf("After child process modify data =%d\n",data);
        exit(0);
    }else{
        printf("This is parent process=%d!\n",data);
    }
 
    getchar();
 
    return 0;
}

root@ubuntu:zhuxl$ ./a.out
This is child process, data=10!
After child process modify data =90
This is parent process=90!

Historic description
    Under Linux, fork(2) is implemented using copy-on-write pages, so the only penalty incurred by fork(2) is the time and memory  required
    to  duplicate  the  parent's  page tables, and to create a unique task structure for the child.  However, in the bad old days a fork(2)
    would require making a complete copy of the caller's data space, often needlessly, since usually immediately afterward  an  exec(3)  is
    done.   Thus,  for greater efficiency, BSD introduced the vfork() system call, which did not fully copy the address space of the parent
    process, but borrowed the parent's memory and thread of control until a call to execve(2) or an exit occurred.  The parent process  was
    suspended  while  the  child  was  using  its  resources.  The use of vfork() was tricky: for example, not modifying data in the parent
    process depended on knowing which variables were held in a register.

Linux description
    vfork(), just like fork(2), creates a child process of the calling process.  For details and return value and errors, see fork(2).
 
    vfork() is a special case of clone(2).  It is used to create new processes without copying the page tables of the parent  process.   It
    may be useful in performance-sensitive applications where a child is created which then immediately issues an execve(2).
 
    vfork()  differs from fork(2) in that the calling thread is suspended until the child terminates (either normally, by calling _exit(2),
    or abnormally, after delivery of a fatal signal), or it makes a call to execve(2).  Until that point, the child shares all memory  with
    its  parent,  including the stack.  The child must not return from the current function or call exit(3) (which would have the effect of
    calling exit handlers established by the parent process and flushing the parent's stdio(3) buffers), but may call _exit(2).
 
    As with fork(2), the child process created by vfork() inherits copies of  various  of  the  caller's  process  attributes  (e.g.,  file
    descriptors, signal dispositions, and current working directory); the vfork() call differs only in the treatment of the virtual address
    space, as described above.
 
    Signals sent to the parent arrive after the child releases the parent's memory (i.e., after the child terminates or calls execve(2)).

Linux notes
    Fork  handlers  established  using  pthread_atfork(3)  are not called when a multithreaded program employing the NPTL threading library
    calls vfork().  Fork handlers are called in this case in a program using the LinuxThreads threading library.  (See  pthreads(7)  for  a
    description of Linux threading libraries.)
 
    A call to vfork() is equivalent to calling clone(2) with flags specified as:
 
         CLONE_VM | CLONE_VFORK | SIGCHLD