进程创建之fork系统调用
4 进程创建 (1)
4.1 实验内容及要求 (1)
4.2 实验目的 (1)
4.3 实验环境 (1)
4.4 实验思路 (1)
4.5 实验代码 (2)
4.6 运行结果 (3)
4.7 实验心得 (3)
4 进程创建
4.1 实验内容及要求
利用fork()系统调用创建进程。
要求如下：
编制一段程序，使用系统调用fork( )创建两个子进程，这样在此程序运行时，在系统中就有一个父进程和两个子进程在活动。
每一个进程在屏幕上显示一个字符，其中父进程显示字符A，子进程分别显示字符 B和字符C。
试观察、记录并分析屏幕上进程调度的情况。
4.2 实验目的
了解进程的创建过程，进一步理解进程的概念，明确进程和程序的区别。
4.3 实验环境
Ubuntu 18.04.1 LTS 64位，编译器gcc 7.3.0 (Ubuntu 7.3.0-16ubuntu3)
4.4 实验思路
（1）可用fork()系统调用来创建一个新进程。
系统调用格式：pid=fork()
fork()返回值意义如下：
=0：若返回值为0，表示当前进程是子进程。
>0：若返回值大于0，表示当前进程是父进程，返回值为子进程的pid值。
<0：若返回值小于0，表示进程创建失败。
如果fork()调用成功，它向父进程返回子进程的pid，并向子进程返回0，即fork()被调用了一次，但返回了两次。
此时OS在内存中建立一个新进程，所建的新进程是调用fork()父进程的副本，称为子进程。
子进程继承了父进程的许多特性，并具有与父进程完全相同的用户级上下文。
父进程与子进程并发执行。
（2）编译和执行的方法：
编译：在shell提示符下输入gcc 源文件名 -o 可执行文件名
运行：在shell提示符下输入 ./可执行文件名
4.5 实验代码
#include<unistd.h>
#include<stdlib.h>
#include<stdio.h>
int main(void) {
pid_t p1=fork();pid_t p2=fork(); //迭代调用fork(),创建三个新进程printf("this is parent, pid = %d\n", getpid()); //父进程
if(p1<0||p2<0){ //fork()失败
printf("fork failed with p1=%d, p2=%d\n", p1, p2);
exit(1);
}if(p1==0&&p2==0){ //子进程B创建的子进程D，即孙进程
printf("D in grandson Damson, pid = %d\n", getpid());
}if(p1==0&&p2>0){ //父进程创建的子进程B
printf("B in child Blueberry, pid = %d\n", getpid());
}if(p1>0&&p2==0){ //父进程创建的子进程C
printf("C in child Carambola, pid = %d\n", getpid());
}if(p1>0&&p2>0){ //父进程
printf("A in parent Apple, pid = %d\n", getpid());
}return 0;
}
4.6 运行结果
编译源文件4.c得到可执行文件文件4，运行如下：
4.7 实验心得
每次调用fork()函数，从代码层理解，相当于自fork()之后的所有代码复制了一份给新进程。
原来的进程和新进程执行相同的代码，但进程标识PID不同。
fork系统调用实验原理
fork系统调用实验原理
fork系统调用是UNIX和Linux操作系统中的一个重要功能，它的主要作用是创建一个与原进程几乎完全相同的子进程。
以下是fork系统调用的实验原理：
1. 父进程在调用fork时，会创建一个与父进程几乎完全相同的子进程。
这个子进程会继承父进程的所有内存空间、文件描述符、环境变量等资源。
2. 在子进程创建完成后，fork系统调用会返回两次，一次是在父进程中返回子进程的PID，一次是在子进程中返回0。
这是fork系统调用的一个重要特性，即“一次调用，两次返回”。
3. 在父进程中，fork返回子进程的PID，这样父进程就可以通过这个PID 来对子进程进行控制和通信。
同时，父进程可以继续执行后续的代码，与子进程并行执行。
4. 在子进程中，fork返回0，表示当前是子进程。
子进程可以继续执行后续的代码，与父进程并行执行。
由于子进程是父进程的副本，因此子进程可以独立地运行，不受父进程的影响。
5. fork系统调用的实现原理是基于操作系统的虚拟存储器技术。
在fork过程中，父进程的虚拟存储空间被拷贝给了子进程，这样父子进程就可以共享内存空间。
但是，这种共享只是虚拟存储空间的共享，实际的物理存储器仍然是分开的。
当父子进程对内存进行写操作时，会触发写时拷贝机制，将物
理存储器中的内容复制到新的物理页面中，从而实现多进程的隔离和并发执行。
通过以上原理，我们可以理解到fork系统调用的作用是创建子进程，并实现父子进程的并行执行。
同时，fork系统调用的实现原理是基于虚拟存储器和写时拷贝技术，实现了多进程的隔离和并发执行。
操作系统实验3进程的创建控制实验
操作系统实验3进程的创建控制实验实验三的目标是通过实现一个进程控制程序，来加深我们对进程创建和控制机制的理解，并通过实践来熟悉和掌握相关的编程技巧。
在进行实验之前，我们需要先了解进程的一些基本概念和相关知识。
首先，进程的创建是通过操作系统中的系统调用来完成的。
在Linux系统中，常用的创建进程的系统调用有fork(和exec(。
fork(系统调用可以创建一个新的进程，该进程与调用fork(的进程几乎完全相同；而exec(系统调用则在新创建的进程中执行一个新的程序。
另外，进程的控制机制主要是通过进程的状态来实现的。
进程可以处于就绪状态、运行状态和阻塞状态。
就绪状态的进程可以被调度器选择后立即运行，而阻塞状态的进程则需要等待一些条件满足后才能被唤醒并变为就绪状态。
实验三的具体内容包括：1. 编写一个程序，通过调用fork(创建多个子进程。
子进程和父进程可以并行执行，共享程序的代码和数据段。
2. 子进程通过调用exec(系统调用执行不同的程序。
可以通过调用不同的exec(函数或者传入不同的参数来执行不同的程序。
3. 子进程执行的程序可能会产生不同的结果，比如输出不同的字符串或者产生不同的返回值。
我们可以通过wait(系统调用等待子进程退出，并获取子进程的返回值。
4. 父进程可以通过调用waitpid(系统调用来选择等待一些特定的子进程，以及获取特定子进程的返回值。
通过实验三的实践，我将更加深入地了解进程的创建和控制机制。
实验三的实验结果将让我熟悉和掌握相关的编程技巧，为我今后更加熟练地编写和控制进程打下坚实的基础。
总之，实验三是一个非常有意义的实验，将帮助我更加深入地理解进程的创建和控制机制，并通过实践获得相关的编程技巧。
这将对我今后的学习和实践有很大的帮助。
fork系统调用
fork系统调用（1） fork系统调用说明fork系统调用用于从已存在进程中创建一个新进程，新进程称为子进程，而原进程称为父进程。
fork调用一次，返回两次，这两个返回分别带回它们各自的返回值，其中在父进程中的返回值是子进程的进程号，而子进程中的返回值则返回 0。
因此，可以通过返回值来判定该进程是父进程还是子进程。
使用fork函数得到的子进程是父进程的一个复制品，它从父进程处继承了整个进程的地址空间，包括进程上下文、进程堆栈、内存信息、打开的文件描述符、信号控制设定、进程优先级、进程组号、当前工作目录、根目录、资源限制、控制终端等，而子进程所独有的只有它的进程号、计时器等。
因此可以看出，使用fork系统调用的代价是很大的，它复制了父进程中的数据段和堆栈段里的绝大部分内容，使得fork系统调用的执行速度并不很快。
fork的返回值这样设计是有原因的，fork在子进程中返回0，子进程仍可以调用getpid函数得到自己的进程ID，也可以调用getppid函数得到父进程的进程ID。
在父进程中使用getpid函数可以得到自己的进程ID，然而要想得到子进程的进程ID，只有将fork的返回值记录下来，别无它法。
fork的另一个特性是所有由父进程打开的文件描述符都被复制到子进程中。
父、子进程中相同编号的文件描述符在内核中指向同一个file结构体，也就是说，file结构体的引用计数要增加。
由于代码段（加载到内存的执行码）在内存中是只读的，所以父子进程可共用代码段，而数据段和堆栈段子进程则完全从父进程复制拷贝了一份。
（2）父进程进行fork系统调用时完成的操作假设id=fork()，父进程进行fork系统调用时，fork所做工作如下：①为新进程分配task_struct任务结构体内存空间。
②把父进程task_struct任务结构体复制到子进程task_struct任务结构体。
③为新进程在其内存上建立内核堆栈。
④对子进程task_struct任务结构体中部分变量进行初始化设置。
linux中fork的作用
linux中fork的作用在Linux中，fork(是一个非常重要的系统调用。
它的作用是创建一个新的进程，这个新的进程被称为子进程，而原始进程被称为父进程。
fork(系统调用会在父进程和子进程之间复制一份相同的当前执行状态，包括程序的代码、数据、堆栈以及其他相关资源。
当一个进程调用fork(时，操作系统会将当前的进程映像复制一份，包括进程的地址空间、文件描述符、信号处理器等。
然后操作系统会分配一个唯一的进程ID（PID）给子进程，父进程和子进程会分别返回子进程的PID和0。
子进程会从fork(调用的位置开始执行，而父进程则继续执行接下来的指令。
fork(的作用有以下几个方面：1. 多任务处理：通过fork(，一个进程可以生成多个子进程，每个子进程可以执行不同的任务。
这种多任务处理的能力是Linux操作系统的基石之一，它允许同时运行多个进程，从而提高系统的并发性和响应性能。
2. 进程间通信：fork(可以为不同的进程提供通信机制。
子进程可以通过进程间通信（IPC）机制与父进程进行数据交换，包括管道、消息队列、共享内存等。
这样实现了进程间的数据共享和协同工作。
3. 服务器模型：fork(在服务器模型中起到关键作用。
通过fork(，一个服务器进程可以创建多个子进程来处理客户端请求。
子进程在接收到请求后，可以独立地为客户端提供服务，这样能够极大地提高服务器的吞吐量和并发处理能力。
4. 资源管理：通过fork(，Linux可以对资源进行有效的管理。
当一个进程需要一个完全相同的副本来执行其他任务时，可以使用fork(来复制当前进程的状态。
这种状态的复制可以节省时间和资源，避免了重新加载和初始化的开销。
5. 守护进程创建：守护进程是在后台执行的长时间运行的进程，不依赖于任何终端。
通过调用fork(，父进程可以使自己成为一个后台进程，并终止自己，而子进程则变为一个孤儿进程并被init进程接管。
这样，守护进程就能够在系统启动后一直运行，提供服务。
linux操作系统下fork函数理解
linux操作系统下fork函数理解在Linux操作系统中，fork函数是一个非常重要的系统调用，它用于创建一个新的进程。
本文将详细解释fork函数的作用、用法和实现原理，并介绍如何利用fork函数实现进程间通信以及避免一些常见的问题。
一、fork函数的作用和用法在Linux系统中，fork函数用于创建一个新的进程，该进程是调用fork函数的进程的一个副本。
具体而言，fork函数会创建一个新的进程，称为子进程，而调用fork函数的进程被称为父进程。
子进程从fork函数返回的地方开始执行，而父进程则继续执行fork函数之后的代码。
简单来说，fork函数的作用就是将一个进程复制成两个几乎完全相同的进程，但它们具有不同的进程ID（PID）。
fork函数的用法非常简单，只需要在程序中调用fork()即可。
具体代码如下所示：```c#include <stdio.h>#include <sys/types.h>#include <unistd.h>int main() {pid_t pid = fork();if (pid == 0) {// 子进程代码} else if (pid > 0) {// 父进程代码} else {// fork失败的处理代码}return 0;}```在上述代码中，首先使用pid_t类型的变量pid存储fork函数的返回值。
如果pid等于0，则表示当前执行的是子进程的代码；如果pid大于0，则表示当前执行的是父进程的代码；如果pid小于0，则表示fork函数调用失败。
二、fork函数的实现原理在Linux系统中，fork函数的实现是通过复制父进程的内存空间来创建子进程的。
具体来说，fork函数会创建一个新的进程控制块（PCB），并将父进程的PCB全部复制到子进程的PCB中，包括代码段、数据段、堆栈等。
由于子进程是父进程的一个副本，所以它们的代码和数据是完全相同的。
fork的底层实现方式
fork的底层实现方式Fork是Unix系统中的一个重要概念，它可以创建一个新的进程，这个新的进程是原进程的一个副本。
在Unix系统中，每个进程都有一个唯一的进程ID，fork会为新的进程分配一个新的进程ID，并且这个新的进程会继承原进程的所有资源，包括代码段、数据段、堆栈、文件描述符等等。
那么，fork的底层实现方式是什么呢？在Unix系统中，fork是通过系统调用来实现的。
当一个进程调用fork时，操作系统会为新的进程创建一个新的进程控制块（PCB），并将原进程的PCB复制一份到新的进程的PCB中。
这样，新的进程就拥有了原进程的所有资源。
在fork的实现过程中，操作系统会为新的进程分配一个新的虚拟地址空间，并将原进程的虚拟地址空间复制一份到新的进程的虚拟地址空间中。
这个过程被称为“写时复制”（Copy-On-Write）。
也就是说，当新的进程需要修改某个资源时，操作系统会将这个资源从原进程的虚拟地址空间中复制一份到新的进程的虚拟地址空间中，然后再进行修改。
这样，就避免了资源的重复复制，提高了fork的效率。
除了资源的复制外，fork还需要进行一些其他的操作。
例如，新的进程需要拥有自己的进程ID、父进程ID、用户ID、组ID等等。
操作系统会为新的进程分配一个新的进程ID，并将原进程的进程ID作为新进程的父进程ID。
此外，新的进程还需要重新打开文件描述符、清空信号处理器等等。
总的来说，fork的底层实现方式是通过系统调用来实现的。
在实现过程中，操作系统会为新的进程创建一个新的进程控制块，并将原进程的所有资源复制一份到新的进程中。
为了提高效率，操作系统采用了“写时复制”的技术，避免了资源的重复复制。
此外，新的进程还需要进行一些其他的操作，例如重新打开文件描述符、清空信号处理器等等。
操作系统实验二(进程管理)
操作系统进程管理实验实验题目：（1）进程的创建编写一段程序，使用系统调用fork( )创建两个子进程。
当此程序运行时，在系统中有一个父进程和两个子进程活动。
让每一个进程在屏幕上显示一个字符：父进程显示字符“a”；子进程分别显示字符“b”和字符“c”。
试观察记录屏幕上的显示结果，并分析原因。
（2）进程的控制修改已编写的程序，将每个进程输出一个字符改为每个进程输出一句话，在观察程序执行时屏幕上出现的现象，并分析原因。
（3）编制一段程序，使其实现进程的软中断通信。
要求：使用系统调用fork( )创建两个子进程，再用系统调用signal( )让父进程捕捉键盘上来的中断信号（即按Del键）；当捕捉到中断信号后，父进程调用系统调用kill( )向两个子进程发出信号，子进程捕捉到信号后分别输出下列信息后终止： Child process 1 is killed by parent! Child process 2 is killed by parent! 父进程等待两个子进程终止后，输出如下的信息后终止： Parent process is killed! 在上面的程序中增加语句signal(SIGINT, SIG_IGN)和signal(SIGQUIT, SIG_IGN)，观察执行结果，并分析原因。
（4）进程的管道通信编制一段程序，实现进程的管道通信。
使用系统调用pipe( )建立一条管道线；两个进程P1和P2分别向管道各写一句话： Child 1 is sending a message! Child 2 is sending a message! 而父进程则从管道中读出来自于两个子进程的信息，显示在屏幕上。
要求父进程先接收子进程P1发来的消息，然后再接收子进程P2发来的消息。
实验源程序及报告：（1）、进程的创建#include <stdio.h>int main(int argc, char *argv[]){int pid1,pid2; /*fork first child process*/if ( ( pid1=fork() ) < 0 ){printf( "ProcessCreate Failed!");exit(-1);}if ( ( pid1=fork() ) == 0 ){printf( "b\n" );}/*fork second child process*/if ( ( pid2=fork() ) < 0 ){printf( "ProcessCreate Failed!"); exit(-1);}if ( ( pid2=fork() ) == 0 ){printf( "c\n" );}/*parent process*/else{wait(NULL);printf( "a\n" );exit(0);}return 0;}（2）、进程的控制#include <stdio.h>int main(int argc, char *argv[]){ int pid1,pid2;/*fork first child process*/if ( ( pid1=fork() ) < 0 ){printf( "ProcessCreate Failed!");exit(-1);}if ( ( pid1=fork() ) == 0 ){printf( "This is my Unix OS program!\n" ); }/*fork second child process*/if ( ( pid2=fork() ) < 0 ){printf( "ProcessCreate Failed!");exit(-1);}if ( ( pid2=fork() ) == 0 ){printf( "This is the second Child process!\n" ); }/*parent process*/else{wait(NULL);printf( "This is the Parent process\n" );exit(0);}return 0;}（3）编制一段程序，使其实现进程的软中断通信。
父子进程的说法
父子进程的说法
"父子进程"是指在操作系统中，由一个进程创建（通常是通过fork系统调用）的进程关系。
这种关系通常用于实现并发执行或并行计算，允许父进程和子进程在独立的执行空间中运行。
以下是关于父子进程的一些说明：
1.父进程：执行fork系统调用的进程称为父进程。
父进程在创建子进程后，通常会继续执行一些任务，或者等待子进程完成执行。
2.子进程：通过fork系统调用创建的新进程称为子进程。
子进程是父进程的副本，拥有独立的内存空间，但通常会继承父进程的代码段、数据段、文件描述符等信息。
3.进程独立性：父进程和子进程之间是相对独立的，它们可以并发执行，互不影响。
子进程的修改通常不会影响父进程，反之亦然。
4.通信机制：父子进程之间可以通过进程间通信（Inter-Process Communication，IPC）来进行数据交换。
常见的IPC方法包括管道、共享内存、消息队列等。
5.等待子进程：父进程通常会使用wait系统调用等待子进程的结束，并获取子进程的退出状态。
这样可以确保父进程在子进程执行完毕后进行进一步的处理。
在多进程的环境中，父子进程的概念非常重要，它们共同构成了并发执行的基础。
在Unix/Linux等操作系统中，fork系统调用是实现多进程的一种常见方式。
fork函数 用法
fork函数用法**标题：fork函数用法详解****一、概述**fork函数是Unix/Linux操作系统中常用的系统调用之一，它用于创建一个新的进程，并返回新进程的进程ID。
这个函数是在调用进程中创建新进程的基础，可以在当前进程的基础上，生成一个新的子进程，父进程和子进程之间可以共享一些数据，但是也必须考虑并发环境中的安全问题。
**二、函数原型**在Unix/Linux系统中，fork函数的基本原型为：intfork(void)。
这个函数会在调用它的进程中创建一个新的进程，并返回两个值：新创建的子进程的进程ID和父进程的进程ID。
如果返回值为-1，则表示fork函数调用失败。
**三、使用场景**fork函数主要用于创建一个新的进程，该进程继承了父进程的环境和状态。
在多线程或多进程编程中，fork函数可以帮助我们更好地管理并发环境中的资源。
例如，在父进程中创建一个新的子进程来执行一些特定的任务，子进程可以继承父进程的一些资源（如打开的文件描述符），而父进程则可以继续执行其他任务。
**四、注意事项**在使用fork函数时，需要注意以下几点：1. fork函数会创建一个新的进程，并返回两个值。
因此，需要确保在调用fork函数之前已经正确地分配了足够的内存空间来保存返回的两个值。
2. fork函数创建的新进程与原进程共享一些资源（如打开的文件描述符），但也需要注意并发环境中的安全问题。
例如，需要确保在子进程中关闭父进程打开的文件描述符，以避免资源泄漏。
3. 在子进程中执行一些操作时，需要考虑到父进程的状态和环境。
例如，如果父进程正在等待某个条件成立（如某个文件被修改），则需要考虑到子进程是否会改变这个条件。
4. fork函数在创建新进程时，会复制一部分父进程的内存空间到新的子进程中。
因此，如果父进程的内存空间非常大，则创建子进程所消耗的时间和内存也会相应增加。
**五、示例代码**下面是一个简单的示例代码，展示了fork函数的使用方法：```c#include <stdio.h>#include <unistd.h>#include <sys/types.h>int main() {pid_t pid; // 用于保存新创建的子进程的进程ID// 调用fork函数创建新进程pid = fork();// 判断fork函数是否成功if (pid < 0) {printf("Fork failed!\n");return 1;} else if (pid == 0) { // 子进程结束循环执行完毕后返回0，否则返回-1结束程序运行// 子进程代码段...while(1) { // 循环执行一些任务...} } else { // 父进程代码段...} // 父进程继续执行其他任务...}```六、总结**fork函数是Unix/Linux系统中的一个重要系统调用，用于在调用进程中创建一个新的子进程。
linux 中的进程处理和控制方式
linux 中的进程处理和控制方式Linux 是一种广泛使用的操作系统，它具有强大的进程处理和控制功能。
在 Linux 系统中，进程是进行任务的基本单位，它们可以同时运行，互相通信，共享资源，因此进程处理和控制是 Linux 系统重要的组成部分。
Linux 提供了多种方式来处理和控制进程。
以下是一些常见的方式：1. 创建新进程：在 Linux 系统中，可以通过 fork() 系统调用创建一个新的子进程。
子进程是通过复制父进程的内存空间、文件描述符和其他资源来创建的。
这样可以实现并行处理任务，提高系统的效率。
创建新进程时，可以使用 exec() 系统调用来加载一个新的程序运行。
2. 进程调度：Linux 使用调度器（scheduler）来决定哪个进程在何时执行。
调度算法会根据进程的优先级（priority）和调度策略来决定进程的执行顺序。
常见的调度策略包括先进先出（FIFO）、最短作业优先（SJF）、轮转（Round Robin）等。
通过合理的调度算法，可以提高系统的响应速度和资源利用率。
3. 进程间通信：在 Linux 中，进程之间可以通过多种方式进行通信。
其中最常用的方式是通过管道（pipe）、信号（signal）和共享内存（shared memory）来进行进程间的数据交换。
管道可以实现进程的单向通信，信号可以用于进程之间的异步通信，而共享内存可以让多个进程共享同一片内存区域，实现高效的数据交换。
4. 进程控制：Linux 提供了多个命令和系统调用来控制进程的行为。
例如，可以使用 ps 命令来查看系统中正在运行的进程，使用kill 命令发送信号终止进程，使用 nice 命令来改变进程的优先级等。
此外，还可以使用进程控制信号（Process Control Signals）来改变进程的状态，如暂停、继续、停止等。
5. 进程管理工具：Linux 提供了一些进程管理工具来帮助用户更方便地处理和控制进程。