用户态进程/线程的创建Fork/vfork/Pthread_Create

[[406068]]

fork

fork 函数创建子进程成功后，父进程返回子进程的 pid，子进程返回0。具体描述如下：

  • fork返回值为-1， 代表创建子进程失败
  • fork返回值为0，代表子进程创建成功，这个分支是子进程的运行逻辑
  • fork返回值大于0，这个分支是父进程的运行逻辑，并且返回值等于子进程的 pid

我们看下通过 fork 系统调用来创建子进程的例子:

 
 
 
 
    
  
  
  
  
  1. #include  
    2. 
  
  
  
  
  2. #include  
    3. 
  
  
  
  
  3. #include  
    4. 
  
  
  
  
  4.   
    5. 
  
  
  
  
  5. int main() 
    6. 
  
  
  
  
  6. { 
    7. 
  
  
  
  
  7.    pid_t pid = fork(); 
    8. 
  
  
  
  
  8.   
    9. 
  
  
  
  
  9.    if(pid == -1){ 
    10. 
  
  
  
  
  10.        printf("create child process failed!\n"); 
    11. 
  
  
  
  
  11.        return -1; 
    12. 
  
  
  
  
  12.    }else if(pid == 0){ 
    13. 
  
  
  
  
  13.        printf("This is child process!\n"); 
    14. 
  
  
  
  
  14.    }else{ 
    15. 
  
  
  
  
  15.        printf("This is parent process!\n"); 
    16. 
  
  
  
  
  16.        printf("parent process pid = %d\n",getpid()); 
    17. 
  
  
  
  
  17.        printf("child process pid = %d\n",pid); 
    18. 
  
  
  
  
  18.    } 
    19. 
  
  
  
  
  19.   
    20. 
  
  
  
  
  20.    getchar(); 
    21. 
  
  
  
  
  21.   
    22. 
  
  
  
  
  22.    return 0; 
    23. 
  
  
  
  
  23. } 
    24.

运行结果：

 
 
 
 
    
  
  
  
  
  1. $ ./a.out 
    2. 
  
  
  
  
  2. This is parent process! 
    3. 
  
  
  
  
  3. parent process pid = 25483 
    4. 
  
  
  
  
  4. child process pid = 25484 
    5. 
  
  
  
  
  5. This is child process! 
    6.

从上面的运行结果来看，子进程的pid=25484， 父进程的pid=25483。

在前面介绍内存缺页异常的时候，提到写时复制 COW 是一种推迟或者避免复制数据的技术，主要用在 fork 系统调用里，当执行 fork 创建新子进程时，内核不需要复制父进程的整个进程地址空间给子进程，而是让父进程和子进程共享同一个副本，只有写入时，数据才会被复制。我们用一个简单里的例子描述下：

 
 
 
 
    
  
  
  
  
  1. #include  
    2. 
  
  
  
  
  2. #include  
    3. 
  
  
  
  
  3. #include  
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. int peter = 10; 
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7. int main() 
    8. 
  
  
  
  
  8. { 
    9. 
  
  
  
  
  9.   pid_t pid = fork(); 
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11.   if(pid == -1){ 
    12. 
  
  
  
  
  12.       printf("create child process failed!\n"); 
    13. 
  
  
  
  
  13.       return -1; 
    14. 
  
  
  
  
  14.   }else if(pid == 0){ 
    15. 
  
  
  
  
  15.       printf("This is child process, peter = %d!\n", peter); 
    16. 
  
  
  
  
  16.       peter = 100; 
    17. 
  
  
  
  
  17.       printf("After child process modify peter = %d\n", peter); 
    18. 
  
  
  
  
  18.   }else{ 
    19. 
  
  
  
  
  19.       printf("This is parent process = %d!\n", peter); 
    20. 
  
  
  
  
  20.   } 
    21. 
  
  
  
  
  21.  
    22. 
  
  
  
  
  22.   getchar(); 
    23. 
  
  
  
  
  23.  
    24. 
  
  
  
  
  24.   return 0; 
    25. 
  
  
  
  
  25. } 
    26.

执行结果：

 
 
 
 
    
  
  
  
  
  1. $ ./a.out 
    2. 
  
  
  
  
  2. This is parent process = 10! 
    3. 
  
  
  
  
  3. This is child process, peter = 10! 
    4. 
  
  
  
  
  4. After child process modify peter = 100 
    5.

从运行结果可以看到，不论子进程如何去修改 peter 的值，父进程永远看到的是自己的那一份。

vfork

接下来看下使用 vfork 来创建子进程:

 
 
 
 
    
  
  
  
  
  1. #include  
    2. 
  
  
  
  
  2. #include  
    3. 
  
  
  
  
  3. #include  
    4. 
  
  
  
  
  4. #include  
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6. int peter = 10; 
    7. 
  
  
  
  
  7.  
    8. 
  
  
  
  
  8. int main() 
    9. 
  
  
  
  
  9. { 
    10. 
  
  
  
  
  10.   pid_t pid = vfork(); 
    11. 
  
  
  
  
  11.  
    12. 
  
  
  
  
  12.   if(pid == -1){ 
    13. 
  
  
  
  
  13.       printf("create child process failed!\n"); 
    14. 
  
  
  
  
  14.       return -1; 
    15. 
  
  
  
  
  15.   }else if(pid == 0){ 
    16. 
  
  
  
  
  16.       printf("This is child process, peter = %d!\n", peter); 
    17. 
  
  
  
  
  17.       peter = 100; 
    18. 
  
  
  
  
  18.       printf("After child process modify peter = %d\n", peter); 
    19. 
  
  
  
  
  19.       exit(0); 
    20. 
  
  
  
  
  20.   }else{ 
    21. 
  
  
  
  
  21.       printf("This is parent process = %d!\n", peter); 
    22. 
  
  
  
  
  22.   } 
    23. 
  
  
  
  
  23.  
    24. 
  
  
  
  
  24.   getchar(); 
    25. 
  
  
  
  
  25.  
    26. 
  
  
  
  
  26.   return 0; 
    27. 
  
  
  
  
  27. } 
    28.

运行结果：

 
 
 
 
    
  
  
  
  
  1. $ ./a.out 
    2. 
  
  
  
  
  2. This is child process, peter = 10! 
    3. 
  
  
  
  
  3. After child process modify peter = 100 
    4. 
  
  
  
  
  4. This is parent process = 100! 
    5.

从运行结果中可以看出，当子进程修改了 peter=100 之后，父进程中打印 peter 的值也是100。

pthread_create

现在我们知道了创建进程有两种方式：fork，vfork。那么创建线程呢?

线程的创建接口是用 pthread_create:

 
 
 
 
    
  
  
  
  
  1. #include  
    2. 
  
  
  
  
  2. #include  
    3. 
  
  
  
  
  3. #include  
    4. 
  
  
  
  
  4. #include  
    5. 
  
  
  
  
  5. #include  
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7. int peter = 10; 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9. static pid_t gettid(void) 
    10. 
  
  
  
  
  10. { 
    11. 
  
  
  
  
  11.  return syscall(SYS_gettid); 
    12. 
  
  
  
  
  12. } 
    13. 
  
  
  
  
  13.  
    14. 
  
  
  
  
  14. static void* thread_call(void* arg) 
    15. 
  
  
  
  
  15. { 
    16. 
  
  
  
  
  16.  peter = 100; 
    17. 
  
  
  
  
  17.  printf("create thread success!\n"); 
    18. 
  
  
  
  
  18.  printf("thread_call pid = %d, tid = %d, peter = %d\n", getpid(), gettid(), peter); 
    19. 
  
  
  
  
  19.  return NULL; 
    20. 
  
  
  
  
  20. } 
    21. 
  
  
  
  
  21.  
    22. 
  
  
  
  
  22. int main() 
    23. 
  
  
  
  
  23. { 
    24. 
  
  
  
  
  24.  int ret; 
    25. 
  
  
  
  
  25.  pthread_t thread; 
    26. 
  
  
  
  
  26.  
    27. 
  
  
  
  
  27.  ret = pthread_create(&thread, NULL, thread_call, NULL); 
    28. 
  
  
  
  
  28.  if(ret == -1) 
    29. 
  
  
  
  
  29.      printf("create thread faild!\n"); 
    30. 
  
  
  
  
  30.  
    31. 
  
  
  
  
  31.  ret = pthread_join(thread, NULL); 
    32. 
  
  
  
  
  32.  if(ret == -1) 
    33. 
  
  
  
  
  33.      printf("pthread join failed!\n"); 
    34. 
  
  
  
  
  34.  
    35. 
  
  
  
  
  35.  printf("process pid = %d, tid = %d, peter = %d\n", getpid(), gettid(), peter); 
    36. 
  
  
  
  
  36.  
    37. 
  
  
  
  
  37.  return ret; 
    38. 
  
  
  
  
  38. } 
    39.

运行结果：

 
 
 
 
    
  
  
  
  
  1. $ ./a.out 
    2. 
  
  
  
  
  2. create thread success! 
    3. 
  
  
  
  
  3. thread_call pid = 9719, tid = 9720, peter = 100 
    4. 
  
  
  
  
  4. process pid = 9719, tid = 9719, peter = 100 
    5.

从上面的结果可以看出：进程和线程的 pid 都是相同的。当线程修改了 peter = 100 之后，父进程中打印 peter 的值也是100。

进程线程创建总图

上面介绍了用户态创建进程和线程的方式，以及各个方式的特点。关于其底层的实现本质，我们后面会详细讲解。这里先提供一下三者之间的关系，可见三者最终都会调用 do_fork 实现。

 

但是内核态没有进程线程的概念，内核中只认 task_struct 结构，只要是 task_struct 结构就可以参与调度。关于内核态的任务创建，我们下文见。

名称栏目：用户态进程/线程的创建Fork/vfork/Pthread_Create
当前URL：http://www.shufengxianlan.com/qtweb/news33/450133.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

定制网站知识

各行业网站

专业网站设计　　 　成都印刷厂　　 　网站建设策划方案　　 　网站解决方案　　 　成都雨棚定制　　 　雨棚定制　　 　java虚拟主机　　 　LED亮化工程　　 　关键词优化　　 　普格博源建站　　 　成都网站制作　　 　成都服务器运维　　 　云服务器　　 　广安迈傲建站　　 　崇州搬家公司　　 　腾讯免备案空间　　 　四川成都托管服务器　　 　软文发布平台　　 　服务器托管　　 　邛崃网站建设