简介

根据大碰撞！当Linux多线程遭遇Linux多进程.md文章讲解所作的实验。

测试用例1

  1. #include <stdio.h>
  2. #include <unistd.h>
  3. #include <pthread.h>
  5. void *sub_pthread(void *unused)
  6. {
  7.     printf("Id %d:in %s\n", getpid(), __func__);
  8.     usleep(500);
  9. }
  11. int main(int argc, char **arhv)
  12. {
  13.     int pid;
  14.     pthread_t ptid;
  15.     pthread_create(&ptid, NULL, sub_pthread, NULL);
  16.     if ((pid = fork()) < 0)
  17.     {
  18.         printf("fork failed\n");
  19.     }
  20.     else if (pid == 0)
  21.     {
  22.         printf("ID %d {childdren}\n", getpid());
  23.         while(1);
  24.     }
  25.     else
  26.     {
  27.         printf("ID %d {father}\n", getpid());
  28.         while(1);
  29.     }
  30.     return 0;
  31. }

执行结果

  1. root@zhou 12:46:09 ~/P/L/signal-safe # ./signal-safe1
  2. ID 31888 {father}
  3. ID 31890 {childdren}
  4. Id 31888:in sub_pthread

我们可以看到的是子线程函数只执行了一次，还是被父函数执行的。可是子进程为什么没有执行了？
参考下面两个文章。
谨慎使用多线程中的fork
fork(2) - Linux man page

  1. The child process is created with a single thread--the one that called fork().
  2. The entire virtual address space of the parent is replicated in the child,
  3. including the states of mutexes, condition variables, and other pthreads objects; 
  4. the use of pthread_atfork(3) may be helpful for dealing with problems 
  5. that this can cause.

进程复制的时候，只会复制当前进程对应的一个线程，只有一个当前的正在执行的线程，其他线程都会被丢弃。

测试用例2

  1. #include <pthread.h>
  2. #include <stdio.h>
  3. #include <unistd.h>
  5. pthread_mutex_t lock;
  7. void *sub_pthread(void *unused) {
  8.   while (1) {
  9.     pthread_mutex_lock(&lock);
  10.     printf("sub_pthread has lock\n");
  11.     usleep(500);
  12.     pthread_mutex_unlock(&lock);
  13.     printf("sub_pthread has unlock\n");
  14.     usleep(500);
  15.   }
  16.   pthread_exit(0);
  17. }
  19. int main(int argc, char **arhv) {
  20.   int pid;
  21.   pthread_t ptid;
  22.   pthread_create(&ptid, NULL, sub_pthread, NULL);
  23.   usleep(500);
  24.   if ((pid = fork()) < 0) {
  25.     printf("fork failed\n");
  26.   } else if (pid == 0) {
  27.     printf("ID %d {childdren}\n", getpid());
  28.     fflush(stdout);
  29.     while (1) {
  30.       pthread_mutex_lock(&lock);
  31.       printf("childdren has lock\n");
  32.       usleep(500);
  33.       pthread_mutex_unlock(&lock);
  34.       printf("childdren has unlock\n");
  35.       usleep(500);
  36.     }
  37.   } else {
  38.     printf("ID %d {father}\n", getpid());
  39.     fflush(stdout);
  40.     while (1) {
  41.       pthread_mutex_lock(&lock);
  42.       printf("father has lock\n");
  43.       usleep(500);
  44.       pthread_mutex_unlock(&lock);
  45.       printf("father has unlock\n");
  46.       usleep(500);
  47.     }
  48.   }
  49.   return 0;
  50. }

运行结果

  1. root@zhou 21:36:38 ~/P/L/signal-safe # ./signal-safe2
  2. sub_pthread has lock
  3. ID 1458 {father}
  4. father has lock
  5. sub_pthread has unlock
  6. ID 1460 {childdren}
  7. father has unlock
  8. sub_pthread has lock
  9. sub_pthread has unlock
  10. father has lock
  11. father has unlock
  12. sub_pthread has lock
  13. sub_pthread has unlock
  14. father has lock
  15. father has unlock

我们可以观察到子进程出现了问题，并没有出现childdren has lock这一句信息。原因是子进程并没有得到锁，一直死锁在这里了。
可是为什么了? 为什么子进程得不到锁?
在《Unix环境高级编程 第3版》的12.9章节中是这么描述的

  1. 子进程通过继承整个地址空间的副本，还从父进程那儿继承了每个互斥量、读写锁和条件变量的状态。
  2. 如果父进程包含一个以上的线程，子进程在fork返回以后，
  3. 如果紧接着不是马上调用exec的话，就需要清理锁状态。
  4. 在子进程内部，只存在一个线程，它是由父进程中调用fork的线程的副本构成的。
  5. 如果父进程中的线程占有锁，子进程将同样占有这些锁。
  6. 问题是子进程并不包含占有锁的线程的副本，
  7. 所以子进程没有办法知道它占有了哪些锁、需要释放哪些锁。
  8. ......
  9. 在多线程的进程中，为了避免不一致状态的问题，
  10. POSIX.1声明，在fork返回和子进程调用其中一个exec函数之间，
  11. 子进程只能调用异步信号安全的函数。
  12. 这就限制了在调用exec之前子进程能做什么，但不涉及子进程中锁状态的问题。

我们可以参考线程调度为什么比进程调度更少开销？来分析为什么子进程得不到锁。
首先子进程从父进程继承来了锁的状态。但是在继承锁的状态的时候，此时锁是被sub_pthread持有的。等待fork运行子进程时，锁还是被sub_pthread所持有的。因此了我们

测试用例3