OS之实验二 进程管理

最新推荐文章于 2023-10-23 23:06:35 发布
最新推荐文章于 2023-10-23 23:06:35 发布
阅读量2k 收藏 20
点赞数 2
分类专栏： 操作系统 文章标签： OS Linux 进程管理 fork
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/feng_zhiyu/article/details/80485029
版权

一、fork入门知识

一个进程，包括代码、数据和分配给进程的资源。fork（）函数通过系统调用创建一个与原来进程几乎完全相同的进程，也就是两个进程可以做完全相同的事，但如果初始参数或者传入的变量不同，两个进程也可以做不同的事。
一个进程调用fork（）函数后，系统先给新的进程分配资源，例如存储数据和代码的空间。然后把原来的进程的所有值都复制到新的新进程中，只有少数值与原来的进程的值不同。相当于克隆了一个自己。

看一个例子：

  1 #include <unistd.h>
  2 #include <stdio.h>
  3 int main ()
  4 {
  5     pid_t fpid; //fpid表示fork函数返回的值  
  6     int count=0;
  7     fpid=fork();
  8     if (fpid < 0)
  9         printf("error in fork!");
 10     else if (fpid == 0) {
 11         printf("i am the child process, my process id is %d\n",getp    id());
 12         printf("我是爹的儿子\n");//对某些人来说中文看着更直白。  
 13         count++;
 14     }
 15     else {
 16         printf("i am the parent process, my process id is %d\n",get    pid());
 17         printf("我是孩子他爹\n");
 18         count++;
 19     }
 20     printf("统计结果是: %d\n",count);
 21     return 0;
 22 }

编译运行：

[root@linuxprobe os]# gcc fork_test.c -o fork_test
[root@linuxprobe os]# ./fork_test 
i am the parent process, my process id is 8370
我是孩子他爹
统计结果是: 1
i am the child process, my process id is 8371
我是爹的儿子
统计结果是: 1

在语句fpid=fork()之前，只有一个进程在执行这段代码，但在这条语句之后，就变成两个进程在执行了，这两个进程的几乎完全相同，将要执行的下一条语句都是if(fpid<0)……
为什么两个进程的fpid不同呢，这与fork函数的特性有关。f**ork调用的一个奇妙之处就是它仅仅被调用一次，却能够返回两次**，它可能有三种不同的返回值：
1）在父进程中，fork返回新创建子进程的进程ID；
2）在子进程中，fork返回0；
3）如果出现错误，fork返回一个负值；

在fork函数执行完毕后，如果创建新进程成功，则出现两个进程，一个是子进程，一个是父进程。在子进程中，fork函数返回0，在父进程中，fork返回新创建子进程的进程ID。我们可以通过fork返回的值来判断当前进程是子进程还是父进程。

引用一位网友的话来解释fpid的值为什么在父子进程中不同。“其实就相当于链表，进程形成了链表，父进程的fpid(p 意味point)指向子进程的进程id, 因为子进程没有子进程，所以其fpid为0.

fork出错可能有两种原因：
1）当前的进程数已经达到了系统规定的上限，这时errno的值被设置为EAGAIN。
2）系统内存不足，这时errno的值被设置为ENOMEM。
创建新进程成功后，系统中出现两个基本完全相同的进程，这两个进程执行没有固定的先后顺序，哪个进程先执行要看系统的进程调度策略。
每个进程都有一个独特（互不相同）的进程标识符（process ID），可以通过getpid（）函数获得，还有一个记录父进程pid的变量，可以通过getppid（）函数获得变量的值。

fork执行完毕后，出现两个进程，
这里写图片描述
有人说两个进程的内容完全一样啊，怎么打印的结果不一样啊，那是因为判断条件的原因，上面列举的只是进程的代码和指令，还有变量啊。
执行完fork后，进程1的变量为count=0，fpid！=0（父进程）。进程2的变量为count=0，fpid=0（子进程），这两个进程的变量都是独立的，存在不同的地址中，不是共用的，这点要注意。可以说，我们就是通过fpid来识别和操作父子进程的。
还有人可能疑惑为什么不是从#include处开始复制代码的，这是因为fork是把进程当前的情况拷贝一份，执行fork时，进程已经执行完了int count=0;fork只拷贝下一个要执行的代码到新的进程。
参考：
linux中fork（）函数详解（原创！！实例讲解）

实验内容：
1.进程的创建
编写一段程序，使用系统调用fork（）创建二个子进程。当此程序运行时，在系统中有一个父进程和二个子进程活动。让每一个进程在屏幕上显示一个字符；父进程显示字符‘a’，子进程分别显示字符‘b’和‘c’。

1）编辑程序

[root@linuxprobe os]# vim exp2进程管理一.c 
#include <stdio.h>
main()
{
      int p1,p2;
      while ((p1=fork())==-1);  /*创建子进程*/
      if(p1==0)         /*子进程创建成功*/
         putchar('b');
      else
      {
       while ((p2=fork())==-1); /*创建另一子进程*/
       if(p2==0)
           putchar('c');
       else 
           putchar('a');
  } 
}

2）编译

[root@linuxprobe os]# gcc exp2进程管理一.c -o exp2进程管理一

3）运行

[root@linuxprobe os]# ./exp2进程管理一 
ac[root@linuxprobe os]# b./exp2进程管理一 
ab[root@linuxprobe os]# c./exp2进程管理一 
ba[root@linuxprobe os]# c./exp2进程管理一 
ab[root@linuxprobe os]# c./exp2进程管理一 
bac[root@linuxprobe os]# ./exp2进程管理一 
ab[root@linuxprobe os]# c./exp2进程管理一 
ba[root@linuxprobe os]# c./exp2进程管理一 
ba[root@linuxprobe os]# c./exp2进程管理一 
ab[root@linuxprobe os]# c./exp2进程管理一 
abc[root@linuxprobe os]# ./exp2进程管理一 
abc[root@linuxprobe os]# ./exp2进程管理一 
ac[root@linuxprobe os]# b./exp2进程管理一 
ab[root@linuxprobe os]# c./exp2进程管理一 
a[root@linuxprobe os]# bc./exp2进程管理一 
ba[root@linuxprobe os]# c./exp2进程管理一 
abc[root@linuxprobe os]#

分析：
可以看出多次执行的结果可能不同，这是因为fork()函数一次调用，两次返回。
fork()函数调用前两个进程的代码完全相同，而在调用后的分为两支。父进程和子进程哪个先执行，这和操作系统和调度算法有关
参考：
https://www.cnblogs.com/nosadness/p/4051220.html
https://blog.csdn.net/jason314/article/details/5640969

2.进程的控制
修改已编写的程序，将每个进程的输出由单个字符改成一句话，再观察程序执行时屏幕上出现的现象，并分析其原因。

[root@linuxprobe os]# vim exp2进程管理一2.c
#include <stdio.h>
main()
{
  int p1,p2,i;
  while ((p1=fork())==-1);  /*创建子进程*/
  if(p1==0)
     for(i=0;i<10;i++)  /*子进程创建成功*/
       printf("daughter %d\n",i);
  else
  {
   while ((p2=fork())==-1); /*建另一子进程*/
   if(p2==0)
     for(i=0;i<10;i++)
       printf("son %d\n",i);
   else 
     for(i=0;i<10;i++)
        printf("parent %d\n",i);
  } 
}
[root@linuxprobe os]# ./exp2进程管理一2
daughter 0
parent 0
daughter 1
parent 1
daughter 2
parent 2
daughter 3
parent 3
daughter 4
parent 4
daughter 5
parent 5
daughter 6
parent 6
daughter 7
parent 7
daughter 8
parent 8
daughter 9
parent 9
son 0
son 1
son 2
son 3
son 4
son 5
son 6
son 7
son 8
son 9
[root@linuxprobe os]# ./exp2进程管理一2
daughter 0
daughter 1
daughter 2
daughter 3
daughter 4
daughter 5
daughter 6
daughter 7
daughter 8
daughter 9
parent 0
parent 1
parent 2
parent 3
parent 4
parent 5
parent 6
parent 7
parent 8
parent 9
son 0
son 1
son 2
son 3
son 4
son 5
son 6
son 7
son 8
son 9
[root@linuxprobe os]# ./exp2进程管理一2
parent 0
parent 1
parent 2
parent 3
parent 4
parent 5
parent 6
parent 7
parent 8
parent 9
son 0
son 1
son 2
son 3
son 4
son 5
son 6
son 7
son 8
son 9
daughter 0
daughter 1
daughter 2
daughter 3
daughter 4
daughter 5
daughter 6
daughter 7
daughter 8
daughter 9

分析：
如第一个例子，父进程与子进程的执行结果与操作系统的调度算法有关。

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

#include <stdio.h>
main()
{
  int p1,p2,i;
  while ((p1=fork())==-1);  /*创建子进程*/
  if(p1==0)
  {  lockf(1,1,0);
     for (i=0;i<10;i++) /*子进程创建成功*/
       printf("daughter %d\n",i);
     lockf(1,0,0);
  }
  else
  {
   while ((p2=fork())==-1); /*建另一子进程*/
   if(p2==0)
   { 
     lockf(1,1,0);
     for(i=0;i<10;i++)
       printf("son %d\n",i);
     lockf(1,0,0);
   }
   else 
    {
     lockf(1,1,0);
     for(i=0;i<10;i++)
        printf("parent %d\n",i);
     lockf(1,0,0);
    }
  } 
}
[root@linuxprobe os]# ./exp2进程管理一3
parent 0
parent 1
parent 2
parent 3
parent 4
parent 5
parent 6
parent 7
parent 8
parent 9
daughter 0
daughter 1
daughter 2
daughter 3
daughter 4
daughter 5
daughter 6
daughter 7
daughter 8
daughter 9
son 0
son 1
son 2
son 3
son 4
son 5
son 6
son 7
son 8
son 9
[root@linuxprobe os]# ./exp2进程管理一3
daughter 0
daughter 1
daughter 2
daughter 3
daughter 4
daughter 5
daughter 6
daughter 7
daughter 8
daughter 9
son 0
son 1
son 2
son 3
son 4
son 5
son 6
son 7
son 8
son 9
parent 0
parent 1
parent 2
parent 3
parent 4
parent 5
parent 6
parent 7
parent 8
parent 9
[root@linuxprobe os]# ./exp2进程管理一3
parent 0
parent 1
parent 2
parent 3
parent 4
parent 5
parent 6
parent 7
parent 8
parent 9
daughter 0
daughter 1
daughter 2
daughter 3
daughter 4
daughter 5
daughter 6
daughter 7
daughter 8
daughter 9
[root@linuxprobe os]# son 0
son 1
son 2
son 3
son 4
son 5
son 6
son 7
son 8
son 9
./exp2进程管理一3
parent 0
parent 1
parent 2
parent 3
parent 4
parent 5
parent 6
parent 7
parent 8
parent 9
daughter 0
daughter 1
daughter 2
daughter 3
daughter 4
daughter 5
daughter 6
daughter 7
daughter 8
daughter 9
son 0
son 1
son 2
son 3
son 4
son 5
son 6
son 7
son 8
son 9

分析：
多次执行结果都是一个进程执行完毕后，才能执行下一个进程，lockf()函数实现了进程间的互斥。

feng_zhiyu
关注
专栏目录
实验二 进程管理.doc
05-16
通过Linux系统中进程控制有关的系统调用的编程和调试，加深对于进程概念的理解，体验进程创建、撤销的过程和进程调度，掌握进程控制的方法。 加深对进程调度的理解，体验进程调度机制的功能，了解Linux系统中进程调度策略的使用方法。 实验程序的目的为模拟一个调度程序应用某种调度策略控制多个子进程的执行顺序。
操作系统：实验一进程控制实验
最新发布
OraOla的博客
08-30 2969
通过本次实验，我学到了以下几点：学习了如何使用fork()函数创建子进程，以及父子进程之间的关系。理解了使用wait()和waitpid()函数等待子进程结束，并获取子进程的退出状态。掌握了使用execl()函数在子进程中执行外部命令。加深了对进程间通信和进程控制的理解，例如父进程等待子进程退出的过程。熟悉了在C语言中使用系统调用来实现基本的shell解释器功能。总的来说，通过实验，我加深了对进程管理、进程通信和操作系统底层的理解，并且了解了基本的Linux系统。
操作系统——实验二 进程管理
nuoyanli的博客
11-30 9578
1、实验目的 （1）加深对进程概念的理解，明确进程和程序的区别。 （2）进一步认识并发执行的实质。 （3）分析进程竞争资源现象，学习解决进程互斥的方法。 2、实验预备内容 （1）阅读Linux的sched.h源文件，加深对进程管理概念的理解。 （2）阅读Linux的fork.c源文件，分析进程的创建过程。 3、实验内容 （1）进程的创建 编写一段源程序，使系统调用fork()创建两个子进程，当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示字符“a”;子进程分
实验二、进程管理及进程通信（一）实验报告
05-20
1、运行源码 运行进程管理及进程通信（一）中给出的例子，查看自己运行的结果，并进行分析。 2、编写程序 (1)、要求程序运行时，系统中存在如下图(一)的进程树结构，写出程序源代码及程序运行结果并在进程树的相应进程节点上标上进程号。 图一 (2)、父进程利用管道将一字符串交给子进程处理。子进程读字符串，将里面的字符反向后再交给父进程，父进程最后读取并打印反向的字符串
实验二、进程管理
11-17 1303
<br />//#include<stdafx.h> #include<stdio.h> #include<iostream> using namespace std; #define TRUE 1 #define FALSE 0 #define MAXPRI 100 #define NIL -1 struct{ int id;/*进程标识*/ char status; /*进程状态*/; int nextwr; /*指向进程控制块后继的指针*/ int priority;
os.rar_os 仿真_os 进程_仿真进程管理_进程调度_进程调度仿真
09-19
在"os.rar_os 仿真_os 进程_仿真进程管理_进程调度_进程调度仿真"这个压缩包中，我们可以期待找到关于操作系统仿真、进程管理和调度的相关知识，包括源代码和相关说明。 首先，我们要理解操作系统仿真。这是通过...
os实验一-进程控制与描述
10-08
进程控制的目的是为了管理进程的执行顺序，避免进程之间的冲突和资源竞争。 在 Windows 2000 中，进程控制是通过使用 Windows API 函数来实现的。例如，CreateProcess() 函数用于创建新进程，WaitForSingleObject()...
OS.rar_进程同步实验
09-21
这个"OS.rar_进程同步实验"旨在帮助初学者深入理解这一概念。 进程同步是操作系统设计的重要组成部分，它涉及到当两个或多个进程需要共享资源时如何协调它们的执行顺序。在并发执行的环境中，进程可能会同时访问...
操作系统OS第2次实验报告.doc，实验二：进程和线程的创建
11-13
在本次实验中，我们关注的是操作系统中的进程和线程管理，以及它们之间的同步与互斥机制。 首先，实验一涉及了进程的创建。在Linux环境下，通过编写程序`an_ch2_1a`和`an_ch2_1b`，我们体验了如何在C语言中使用系统...
OS实验 进程管理
05-18
### OS实验 进程管理知识点解析 #### 一、实验目的与背景 本实验旨在通过设计和实现一个简单的操作系统进程管理模块，使学生理解和掌握进程的基本概念、进程的状态转换、进程间的调度策略以及同步机制。具体地，...
实验2 Linux进程管理.pdf
06-08
实验2 Linux进程管理.pdf
进程管理实验
10-26
电子科技大学操作系统进程管理过程模拟 基于python编写，有问题csdn交流。
进程管理 实验
10-10
最近在上操作系统课，第一个实验进程管理，我网上查了一下，发现别人写的我很不满意，于是自己用C语言写了一个比较满意的程序，嘿嘿，实现了进程的创建，查看正在运行的进程，进程的通信，杀死进程，同时满足在Linux环境下编译
LINUX进程管理实验
01-08
LINUX进程管理实验，LINUX中的基本实验
实验5：进程管理【nyist】
m0_48385518的博客
04-16 1316
1.实验目的 （1）理解进程与程序的区别。 （2）了解fork( )系统调用的返回值，掌握调用fork( )创建进程的方法。 （3）掌握进程并发执行的原理，理解进程并发执行的特点，区分进程并发执行与串行执行。 （4）能够熟练使用进程管理命令对进程进行管理 2.实验环境 （1）一台已经安装好的Window系统的计算机。 （2）安装好的CentOS虚拟机。 3.实验内容 （1）使用vi编辑器编写C语言程序，调用fork函数创建进程。 编写一段程序，利用系统调用fork( )创建两个进程。当..
操作系统实验二 进程管理
流苏的博客
09-21 1251
操作系统实验二 进程管理
计算机操作系统实验二进程管理
qq_69136441的博客
10-23 921
1、掌握getpid和getppid函数的使用2、掌握fork函数的使用3、理解exec函数族6个函数的区别，掌握6个函数的使用4、理解exit和_exit的区别，掌握exit的使用5、理解wait和waitpid的区别，掌握wait和waitpid的使用。
编写一个程序使用系统调用fork生成3个子进程并使用系统调用pipc创建一个管道,使得
10-21
编写一个程序使用系统调用fork生成3个子进程并使用系统调用pipc创建一个管道，使得子进程之间可以通过管道进行通信。 首先，需要包含头文件<sys/types.h>、<sys/stat.h>、<fcntl.h>、<unistd.h>和<stdio.h>来使用相关的系统调用。 程序的主函数如下所示： ```c #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <unistd.h> #include <stdio.h> int main() { pid_t pid[3]; int fd[2]; // 创建管道 if (pipe(fd) < 0) { perror("创建管道失败"); return 1; } // 创建子进程 for (int i = 0; i < 3; i++) { pid[i] = fork(); if (pid[i] < 0) { perror("创建子进程失败"); return 1; } else if (pid[i] == 0) { // 子进程从管道中读取数据 close(fd[1]); // 关闭写端 char buffer[256]; read(fd[0], buffer, sizeof(buffer)); printf("子进程%d收到的数据：%s\n", i + 1, buffer); return 0; } } // 父进程向管道中写入数据 close(fd[0]); // 关闭读端 char message[] = "Hello, child processes!"; write(fd[1], message, sizeof(message)); return 0; } ``` 在程序中，首先使用系统调用pipe(fd)创建一个管道，fd[0]表示读端，fd[1]表示写端。然后使用for循环创建3个子进程，并在子进程中使用read系统调用从管道中读取数据，并输出接收到的消息。最后，在父进程中使用write系统调用向管道中写入数据。 需要注意的是，在父进程中，需要通过close系统调用关闭不使用的文件描述符，这里关闭了管道的读端fd[0]，以及在子进程中关闭了管道的写端fd[1]。 这样，运行程序后，父进程向管道中写入数据，然后每个子进程从管道中读取数据并输出，实现了子进程之间通过管道进行通信。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值