【Linux实验】fork()创建子进程的一系列测试【进程管理】

川长思鸟来 2023-09-24 14:23 101阅读 0赞

![在这里插入图片描述][505927bd81974f3e81aba622f405f2ae.png]

#include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    int main()
    {
        
       pid_t pid1, pid2;
       while ((pid1 = fork()) == -1);
       if (pid1 == 0)
       {
         printf("b");}
       else
       {
        
          while ((pid2 = fork()) == -1);
          if (pid2 == 0) printf("c");
          else printf("a");
       }
       return 0;
    }

编译后执行：![在这里插入图片描述][439df70dc155474f85c16a1eaea5119d.png]  
**分析：**

*  程序输出为’bac’，其中’b’为pid1的输出，’a’为父进程的输出，’c’为pid2的输出。
 *  首先在执行语句pid1 = fork()时，创建了子进程pid1，此时打印’b’；
 *  然后父进程运行，打印’a’。
 *  最后执行语句pid2 = fork()时，创建了子进程pid2，此时打印’c’；

程序运行多次，发现结果一致，并未有改变。  
原因可能是操作系统总是按照如上的顺序进行运行。

--------------------

**修改程序，将每个进程输出一个字符改为每个进程输出一句话，观察分析显示结果**；

#include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    
    int main()
    {
        
       pid_t pid1, pid2;
       while ((pid1 = fork()) == -1);
       if (pid1 == 0) printf("pid1 here : b\n");
       else
       {
        
          while ((pid2 = fork()) == -1);
          if (pid2 == 0) printf("pid2 here : c\n");
          else printf("father progress here : a\n");
       }
       return 0;
    }

![在这里插入图片描述][cd063b3e106346e7a7d7fcbea47827ef.png]  
结果和之前没有区别，但偶有输出 b c a 可能和操作系统执行顺序有关。

再试试：

**如果在父进程fork之前，输出一句话，这句话后面不加“\\n”或加“\\n”，结果有什么不同，为什么？**

#include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    
    int main()
    {
        
       pid_t pid1, pid2;
       printf("This is a sentence.");
       // printf("This is a sentence.\n");
       while ((pid1 = fork()) == -1);
       if (pid1 == 0) printf("pid1 here : b\n");
       else
       {
        
          while ((pid2 = fork()) == -1);
          if (pid2 == 0) printf("pid2 here : c\n");
          else printf("father progress here : a\n");
       }
       return 0;
    }

*  先不加 \\n

![在这里插入图片描述][fc3206fc61514f5192489dd22023344a.png]

*  加上 \\n

![在这里插入图片描述][07fbb5153fae48a6885f615df5f0d708.png]  
**结果分析：**

*  第一种情况每个进程都打印了This is a sentence.这句话，而第二种情况只打印了一次。

> 查阅相关资料后进行分析：

> （1）**不加’\\n’**：  
> 由于输出时，我们要将内存中的数据输出到磁盘中，系统会先将要printf的内容存到磁盘缓冲区buffer，也就是将This is a sentence.这句话写入buffer。而子进程会继承父进程的buffer内容，于是在子进程中也会打印这句话，第1个子进程会输出，第2个子进程也会输出。

> （2）**加’\\n’**：  
> 系统检测到“\\n”会自动清空缓冲区，于是子进程继承父进程时，缓冲区里面没有要打印这句话的信息，于是在2个子进程中只分别输出c和b。

--------------------

**修改已经编好的程序(使用fork()创建进程)，将每个进程输出一个字符改为每个进程用for循环重复输出一句话，再观察程序执行时屏幕上出现的现象，并分析原因。**

#include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    
    int main()
    {
        
       pid_t pid1, pid2;
       while ((pid1 = fork()) == -1);
       if (pid1 == 0) {
        
        for(int i=0;i<5;i++){
        
            printf("pid1 here : b\n");
        }
       }
       else
       {
        
          while ((pid2 = fork()) == -1);
        if (pid2 == 0) {
        
            for(int i=0;i<5;i++){
        
                printf("pid2 here : c\n");
            }
        }else{
         
            for(int i=0;i<5;i++){
        
            printf("father progress here : a\n");
            }
        }
       }
       return 0;
    }

![在这里插入图片描述][f6123e68cbc74ec0be6afd03d6f3fea7.png]  
**结果分析：**

*  先输出子进程1，然后父进程和子进程2交替输出
 *  因为fork()创建进程所需要的时间要多于输出一个字符的时间
 *  由于函数printf()输出的字符串之间不会被中断，因此，字符串内部的字符顺序输出时不变。但是，由于进程并发执行时的调度顺序和父子进程的抢占处理机问题，处处字符串的顺序和先后随着执行的不同而发生变化。

--------------------

**如果在程序中使用系统调用lockf()来给每一个进程加锁，可以实现进程之间的互斥，观察并分析出现的现象。**

> 如果在程序中使用系统调用lockf来给临界资源加锁，可以实现临界资源的互斥访问。将lockf加在输出语句前后运行试试；将一条输出语句变成多条输出语句，将lockf语句放在循环语句外部或内部试试，观察显示结果并分析原因。

**（一）直接对stdout加锁，发现和之前的输出没有区别，因为进行互斥约束后仍然可以访问stdout中的资源：**

#include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    
    int main()
    {
        
       pid_t pid1, pid2;
       while ((pid1 = fork()) == -1);
       if (pid1 == 0)
       {
        
          lockf(1, 1, 0);
          printf("pid1 here : b\n");
          lockf(1, 0, 0);
       }
       else
       {
        
          while ((pid2 = fork()) == -1);
          if (pid2 == 0)
          {
        
             lockf(1, 1, 0);
             printf("pid2 here : c\n");
             lockf(1, 0, 0);
          }
          else
          {
        
             lockf(1, 1, 0);
             printf("father progress here : a\n");
             lockf(1, 0, 0);
          }
       }
       return 0;
    }

![在这里插入图片描述][f0c5bb5bd6c549dd83de42ac63eca6aa.png]

**（二）进行循环访问并在内部加锁，发现子进程pid1先执行4次输出，然后parent输出，最后是pid2：**

#include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    
    int main()
    {
        
       pid_t pid1, pid2;
       while ((pid1 = fork()) == -1);
       if (pid1 == 0)
       {
        
          for (int i = 0; i < 5; ++i)
          {
        
             lockf(1, 1, 0);
             printf("pid1 here : %d\n", i);
             lockf(1, 0, 0);
          }
       }
       else
       {
        
          while ((pid2 = fork()) == -1);
          if (pid2 == 0)
          {
        
             for (int i = 0; i < 5; ++i)
             {
        
                lockf(1, 1, 0);
                printf("pid2 here : %d\n", i);
                lockf(1, 0, 0);
             }
          }
          else printf("father progress here : a\n");
       }
       return 0;
    }

![在这里插入图片描述][415128165f844a2b923723fde9c1b67a.png]

**（三）进行循环访问并在外部加锁，发现输出情况一样：**

#include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    
    int main()
    {
        
       pid_t pid1, pid2;
       while ((pid1 = fork()) == -1);
       if (pid1 == 0)
       {
        
          lockf(1, 1, 0);
          for (int i = 0; i < 5; ++i)
             printf("pid1 here : %d\n", i);
          lockf(1, 0, 0);
    
       }
       else
       {
        
          while ((pid2 = fork()) == -1);
          if (pid2 == 0)
          {
        
             lockf(1, 1, 0);
             for (int i = 0; i < 5; ++i)
                printf("pid2 here : %d\n", i);
             lockf(1, 0, 0);
          }
          else printf("father progress here : a\n");
       }
       return 0;
    }

![在这里插入图片描述][e6612cdb795d4b51aef4d0fbc67578c3.png]  
**（四）上锁后令进程进行短暂休眠，发现pid1和pid2交替输出，并且父进程不是最后输出：**

#include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    
    int main()
    {
        
       pid_t pid1, pid2;
       while ((pid1 = fork()) == -1);
       if (pid1 == 0)
       {
        
          for (int i = 0; i < 5; ++i)
          {
        
             lockf(1, 1, 0);
             printf("pid1 here : %d\n", i);
             lockf(1, 0, 0);
             sleep(1);
          }
       }
       else
       {
        
          while ((pid2 = fork()) == -1);
          if (pid2 == 0)
          {
        
             for (int i = 0; i < 5; ++i)
             {
        
                lockf(1, 1, 0);
                printf("pid2 here : %d\n", i);
                lockf(1, 0, 0);
                sleep(1);
             }
          }
          else printf("father progress here : a\n");
       }
       return 0;
    }

![在这里插入图片描述][c97726a839ca4fc596a85677b7fa4f5d.png]

**分析：**

*  pid1进程先用lockf(1,1,0)锁上stdout，执行输出之后，立即用lockf(1,0,0)释放stdout,而此时进程休眠了1秒，没有立即又给stdout加锁，在休眠的这段时间，pid2可以获得stdout资源，于是pid2执行输出；同理，pid2加锁，输出，释放锁之后一样也执行了休眠，于是pid1可以获得stdout资源，于是就出现了两个进程交替执行输出的情况。
 *  以上各种情况都运行多次发现运行结果不一定始终保持一致：原因是OS对进程执行的顺序管理和访问互斥共同造成的

--------------------

**思考：**

系统是如何创建进程？当父进程fork子进程后，父进程和子进程从程序什么位置开始执行？为什么？

（1）首先创建父进程，再根据父进程创建子进程。具体而言，是首先通过内核调用sys\_clone来完成，先对父进程的数据和环境进行复制，然后修改新进程的一些属性，之后通过do\_fork函数和ret\_from\_fork函数完成对新进程的创建以及运行。

（2）经过资料查阅，个人认为，fork创建的父子进程并不保证任何有规律的执行顺序。不同linux，不同的系统配置环境，不同的系统负载下很可能结果不一样。

（3）从实验的结果来推测，子进程和父进程都从调用fork函数的下一条语句开始执行。因为程序的顺序执行，也很难想象会从之前的语句重新执行。

[505927bd81974f3e81aba622f405f2ae.png]: https://img-blog.csdnimg.cn/505927bd81974f3e81aba622f405f2ae.png
[439df70dc155474f85c16a1eaea5119d.png]: https://img-blog.csdnimg.cn/439df70dc155474f85c16a1eaea5119d.png
[cd063b3e106346e7a7d7fcbea47827ef.png]: https://img-blog.csdnimg.cn/cd063b3e106346e7a7d7fcbea47827ef.png
[fc3206fc61514f5192489dd22023344a.png]: https://img-blog.csdnimg.cn/fc3206fc61514f5192489dd22023344a.png
[07fbb5153fae48a6885f615df5f0d708.png]: https://img-blog.csdnimg.cn/07fbb5153fae48a6885f615df5f0d708.png
[f6123e68cbc74ec0be6afd03d6f3fea7.png]: https://img-blog.csdnimg.cn/f6123e68cbc74ec0be6afd03d6f3fea7.png
[f0c5bb5bd6c549dd83de42ac63eca6aa.png]: https://img-blog.csdnimg.cn/f0c5bb5bd6c549dd83de42ac63eca6aa.png
[415128165f844a2b923723fde9c1b67a.png]: https://img-blog.csdnimg.cn/415128165f844a2b923723fde9c1b67a.png
[e6612cdb795d4b51aef4d0fbc67578c3.png]: https://img-blog.csdnimg.cn/e6612cdb795d4b51aef4d0fbc67578c3.png
[c97726a839ca4fc596a85677b7fa4f5d.png]: https://img-blog.csdnimg.cn/c97726a839ca4fc596a85677b7fa4f5d.png