进程的创建与并发执行之一实验报告(A35)

一、实验目的1. 理解进程的基本概念，掌握进程的结构和生命周期。

2. 掌握进程的创建、终止、同步和通信的方法。

3. 熟悉进程调度算法和进程同步机制。

4. 通过实验加深对操作系统进程管理的理解。

二、实验环境1. 操作系统：Linux2. 编程语言：C/C++3. 实验工具：gcc、make、xterm三、实验内容1. 进程的创建与终止（1）使用fork()系统调用创建进程编写一个C程序，通过fork()系统调用创建一个子进程。

父进程和子进程分别执行不同的任务，并输出各自的信息。

```c#include <stdio.h>#include <sys/types.h>#include <unistd.h>int main() {pid_t pid;pid = fork();if (pid == -1) {printf("Fork failed!\n");return 1;printf("This is child process, PID: %d\n", getpid()); // 子进程执行的任务} else {printf("This is parent process, PID: %d\n", getpid()); // 父进程执行的任务}return 0;}```（2）使用exec()系统调用替换子进程内容在父进程中，使用exec()系统调用替换子进程的内容，执行新的程序。

```c#include <stdio.h>#include <sys/types.h>#include <sys/wait.h>#include <unistd.h>int main() {pid_t pid;pid = fork();if (pid == -1) {printf("Fork failed!\n");return 1;execlp("ls", "ls", "-l", (char )NULL);printf("Exec failed!\n");return 1;} else {wait(NULL);}return 0;}```2. 进程同步与通信（1）使用管道实现进程通信编写一个C程序，使用管道实现父进程和子进程之间的通信。

进程的创建实验报告进程的创建实验报告引言：在计算机科学领域中，进程是一个非常重要的概念。

进程是计算机程序的执行实例，它具有独立的内存空间和执行环境。

进程的创建是操作系统中一个关键的操作，本实验旨在通过编写一个简单的程序来演示进程的创建过程。

实验目的：通过实验，我们的目标是深入理解进程的创建过程，并了解操作系统是如何管理进程的。

实验步骤：1. 引入必要的头文件：在开始编写代码之前，我们需要引入一些必要的头文件。

这些头文件包括<sys/types.h>、<sys/wait.h>和<unistd.h>。

这些头文件提供了创建进程所需的函数和数据类型。

2. 创建一个子进程：在主程序中，我们使用fork()函数来创建一个子进程。

fork()函数会在当前进程的基础上创建一个新的进程，这个新进程称为子进程。

子进程和父进程几乎完全相同，只有在返回值上有所区别。

如果fork()函数返回0，表示当前进程是子进程；如果返回一个正整数，表示当前进程是父进程。

3. 子进程的执行：在子进程中，我们可以编写任意的代码来执行特定的任务。

子进程可以使用exec()函数来执行其他程序，或者执行一系列的操作。

在本实验中，我们简单地输出一条信息，以展示子进程的执行过程。

4. 父进程的执行：在父进程中，我们可以编写代码来执行其他任务，或者等待子进程的结束。

在本实验中，我们使用wait()函数来等待子进程的结束。

wait()函数会暂停父进程的执行，直到子进程结束为止。

5. 编译和运行程序：在完成代码编写后，我们需要将程序编译成可执行文件，并运行它。

我们可以使用gcc编译器来编译程序，然后运行生成的可执行文件。

实验结果：在运行程序后，我们可以观察到以下结果：子进程开始执行。

父进程等待子进程结束。

子进程结束。

父进程继续执行。

结论：通过本实验，我们成功地演示了进程的创建过程。

我们了解了操作系统是如何管理进程，并且掌握了使用fork()函数来创建子进程的方法。

广州商学院操作系统实验报告（第 2 次）实验名称：进程的创建与并发执行之一实验时间：2021/3/31一．实验目的（1）理解进程与程序的联系与区别以及并发程序的基本特性。

（2）学会在在程序中使用fork() 函数创建克隆式子进程的基本编程方法。

二．实验内容命令进程的创建与并发执行三．实验主要步骤实验2.1 命令进程的创建与并发执行②启动Linux，进入黑屏界面；②在tty1上用root账号登录，在tty2和tty3上则分别以普通用户账号登录；③在tty1上输入命令“ps --help”，即在tty1上创建命令进程ps，以查看ps命令的help信息；④在tty2上输入命令“man man”，即在tty2上创建命令进程man，以查看man命令的help信息，不要终止该man命令；⑤在tty3上执行命令“man pstree”，即在tty3上创建命令进程man，查看pstree命令的help信息，同样也不要终止该man命令；⑥在tty1上执行ps命令，查看本控制台上所有进程的基本信息；⑦在tty1上执行pstree命令，查看进程的分层结构。

⑧再在tty1上执行ps命令，查看本系统的所有进程的详细信息，并从中找到并记下tty2上的man命令进程的PID；你能看到ps命令输出的全部信息吗？如果不能，可以利用Linux的“重定向”或“管道”功能，例如，可输入如下管道命令行：ps –aux | more该命令行的语义是：将ps命令的输出结果作为输入传递给more命令（分页显示），并执行more命令。

)⑨撤消tty2上的man命令进程；⑩再执行ps命令，查看被撤消的进程是否还存在；⑾切换到tty2，观察man命令是否还在执行或已终止；再切换到tty3，观察man命令是否还在执行或已终止；tty2（已经终止）tty3（未终止）⑿注销（不要关机）。

tty3tty2tty1实验2.2 使用fork创建进程本实验使用系统调用fork()创建多个子进程，实现多进程并发执行。

电大操作系统实验报告3_ 进程管理实验电大操作系统实验报告 3 进程管理实验一、实验目的进程管理是操作系统的核心功能之一，本次实验的目的是通过实际操作和观察，深入理解进程的概念、状态转换、进程调度以及进程间的通信机制，掌握操作系统中进程管理的基本原理和方法，提高对操作系统的整体认识和实践能力。

二、实验环境本次实验使用的操作系统为 Windows 10，编程语言为 C 语言，开发工具为 Visual Studio 2019。

三、实验内容及步骤（一）进程的创建与终止1、编写一个 C 程序，使用系统调用创建一个子进程。

2、在父进程和子进程中分别输出各自的进程 ID 和父进程 ID。

3、子进程执行一段简单的计算任务，父进程等待子进程结束后输出结束信息。

以下是实现上述功能的 C 程序代码：｀｀｀cinclude ＜stdioh>include ＜stdlibh>include ＜unistdh>int main(）｛pid_t pid;pid ＝ fork(）；if （pid ＜ 0) ｛printf(＂创建子进程失败\n"）；return 1;｝ else if （pid ＝＝ 0) ｛printf(＂子进程：我的进程 ID 是％d，父进程 ID 是％d\n"，getpid(）， getppid(））；int result ＝ 2 ＋ 3;printf(＂子进程计算结果：2 ＋ 3 ＝％d\n"， result)；exit(0)；｝ else ｛printf(＂父进程：我的进程 ID 是％d，子进程 ID 是％d\n"，getpid(）， pid)；wait(NULL)；printf(＂子进程已结束\n"）；｝return 0;｝｀｀｀编译并运行上述程序，可以观察到父进程和子进程的输出信息，验证了进程的创建和终止过程。

（二）进程的状态转换1、编写一个 C 程序，创建一个子进程，子进程进入睡眠状态一段时间，然后被唤醒并输出状态转换信息。

进程创建实验报告进程创建实验报告引言：进程是计算机系统中的基本概念之一，也是操作系统的核心概念之一。

进程创建是操作系统中的一个重要操作，它涉及到资源的分配和管理，对于操作系统的正常运行具有重要意义。

本实验旨在通过编写一个简单的程序，探索进程创建的过程以及相关概念。

一、实验目的本实验的主要目的是了解进程创建的基本过程，并掌握相关的概念和操作。

通过实践，加深对操作系统的理解和应用。

二、实验环境本实验使用的是Linux操作系统，具体的版本为Ubuntu 20.04 LTS。

在该环境下，我们可以使用C语言编写程序，并通过gcc编译器进行编译和运行。

三、实验步骤1. 编写源代码首先，我们需要编写一个简单的C语言程序，用于创建一个新的进程。

在程序中，我们可以使用fork()函数来创建新的进程。

具体的代码如下：```c#include <stdio.h>#include <unistd.h>int main() {pid_t pid;pid = fork();if (pid < 0) {printf("Failed to create a new process.\n");} else if (pid == 0) {printf("This is the child process.\n");} else {printf("This is the parent process.\n");}return 0;}```2. 编译和运行程序在终端中，使用gcc编译器将源代码编译为可执行文件。

具体的命令如下：```shellgcc -o process_create process_create.c```编译成功后，我们可以通过运行可执行文件来创建新的进程。

具体的命令如下：```shell./process_create```3. 观察输出结果运行程序后，我们可以观察到输出结果。

进程操作实验报告进程操作实验报告一、引言进程是计算机系统中最基本的概念之一，它代表了正在运行的程序。

在操作系统中，进程的管理和操作是非常重要的。

本实验旨在通过对进程操作的实践，加深对进程概念的理解，并掌握进程的创建、调度和终止等操作。

二、实验目的1. 理解进程的概念和基本属性；2. 掌握进程的创建和终止操作；3. 熟悉进程调度算法的实现；4. 加深对操作系统中进程管理的理解。

三、实验环境本次实验使用的操作系统为Linux，并且需要具备C语言编程基础。

四、实验内容1. 进程的创建进程的创建是操作系统中的一个重要操作。

通过调用fork()函数，可以在当前进程的基础上创建一个新的子进程。

子进程将继承父进程的资源，包括内存空间、文件描述符等。

通过实验，我们可以编写一个简单的程序，演示进程的创建过程，并观察子进程和父进程的行为差异。

2. 进程的调度进程调度是操作系统中的核心功能之一。

在多任务系统中，操作系统需要合理地分配CPU时间片，以便每个进程都能得到执行的机会。

常见的调度算法有先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转（RR）等。

通过实验，我们可以编写一个简单的程序，模拟进程的调度过程，并观察不同调度算法对进程执行顺序的影响。

3. 进程的终止进程的终止是操作系统中的另一个重要操作。

通过调用exit()函数，可以结束当前进程的执行，并释放相关资源。

在实验中，我们可以编写一个程序，演示进程的终止过程，并观察终止进程后系统的行为。

五、实验步骤1. 进程的创建实验步骤：（1）编写一个简单的程序，调用fork()函数创建子进程；（2）在父进程和子进程中分别输出不同的信息，以便观察其行为差异；（3）编译并运行程序，观察输出结果。

2. 进程的调度实验步骤：（1）编写一个简单的程序，模拟多个进程的执行；（2）使用不同的调度算法，如FCFS、SJF、RR等，对进程进行调度；（3）观察不同调度算法对进程执行顺序的影响，并比较它们的优缺点。

一、实验目的1. 理解并发执行的概念和原理。

2. 掌握多线程编程的基本方法。

3. 学会使用同步机制解决并发编程中的竞争条件。

4. 分析并发程序的性能和效率。

二、实验环境1. 操作系统：Windows 102. 编程语言：Java3. 开发工具：Eclipse三、实验内容1. 创建一个简单的并发程序，实现两个线程同时执行。

2. 使用同步机制解决并发程序中的竞争条件。

3. 分析并发程序的性能和效率。

四、实验步骤1. 创建一个简单的并发程序（1）创建一个名为ConcurrentTest的类，该类继承自Thread类。

（2）在ConcurrentTest类的run方法中，打印出当前线程的名字。

（3）在主函数中，创建两个ConcurrentTest对象，分别命名为thread1和thread2。

（4）启动thread1和thread2线程。

（5）等待thread1和thread2线程执行完毕。

2. 使用同步机制解决并发程序中的竞争条件（1）创建一个名为Counter的类，该类包含一个私有变量count和一个静态同步方法add。

（2）在add方法中，增加count变量的值。

（3）在主函数中，创建一个Counter对象counter。

（4）创建两个线程，分别调用counter对象的add方法。

（5）启动两个线程，并等待它们执行完毕。

3. 分析并发程序的性能和效率（1）在主函数中，记录两个线程开始执行的时间。

（2）在主函数中，记录两个线程执行完毕的时间。

（3）计算两个线程执行所需的时间差。

五、实验结果与分析1. 实验结果（1）简单的并发程序在控制台中，可以看到thread1和thread2线程交替打印出它们的名字。

（2）使用同步机制解决竞争条件在控制台中，可以看到Counter对象的count变量值正确地增加了。

（3）分析并发程序的性能和效率thread1和thread2线程执行所需的时间差为0.01秒。

2. 实验分析（1）简单的并发程序通过创建两个线程，实现了两个任务同时执行。

进程的创建
一.实验目的
1、掌握进程的概念，明确进程的含义。

2、认识并了解并发执行的实质。

二.实验内容
编写一段程序，使用系统调用fork( )创建一个子进程。

当此程序运行时，在系统中有一个父进程和一个子进程活动。

让每一个进程在屏幕上显示一个字符：父进程显示'a'，子进程显示字符'b'。

试观察记录屏幕上的显示结果，并分析原因。

三.实验过程及结果
1.打开centos，在文档中输入创建进程的代码。

图1 代码界面
2.在桌面上右击，在下拉列表中选择Open in Terminal，打开控制台，然后输入编译和运行的命令，当输入编译命令的时候，桌面会生成一个a.out的文件。

图2 编译界面
3.当输入运行命令，就会显示出结果了
图3 最终结果
四.实验小结
1.代码在执行的时候，就创建了一个进程，此时的进程是父进程。

2.当代码执行到fork()函数时，就创建了一个子进程，因为子进程是继承父进程的，所以他们的内容基本上是一样的。

3.可以看到，在最后输入运行命令时，同时跳出两个结果，证明了进程是并发执行的。

4.对于进程的定义，从不同的角度有不同的定义，较典型的有：进程是程序的一次执行，进程是具有独立功能的程序在一个数据集合上运行的过程，它是系统进行资源分配和调度的一个独立单位等。

5.并发执行就是指两个或者多个事件在同一时间间隔内发生。

第1篇一、实验背景进程管理是操作系统中的一个重要组成部分，它负责管理计算机系统中所有进程的创建、调度、同步、通信和终止等操作。

为了加深对进程管理的理解，我们进行了一系列实验，以下是对实验的分析和总结。

二、实验目的1. 加深对进程概念的理解，明确进程和程序的区别。

2. 进一步认识并发执行的实质。

3. 分析进程争用资源的现象，学习解决进程互斥的方法。

4. 了解Linux系统中进程通信的基本原理。

三、实验内容1. 使用系统调用fork()创建两个子进程，父进程和子进程分别显示不同的字符。

2. 修改程序，使每个进程循环显示一句话。

3. 使用signal()捕捉键盘中断信号，并通过kill()向子进程发送信号，实现进程的终止。

4. 分析利用软中断通信实现进程同步的机理。

四、实验结果与分析1. 实验一：父进程和子进程分别显示不同的字符在实验一中，我们使用fork()创建了一个父进程和两个子进程。

在父进程中，我们打印了字符'a'，而在两个子进程中，我们分别打印了字符'b'和字符'c'。

实验结果显示，父进程和子进程的打印顺序是不确定的，这是因为进程的并发执行。

2. 实验二：每个进程循环显示一句话在实验二中，我们修改了程序，使每个进程循环显示一句话。

实验结果显示，父进程和子进程的打印顺序仍然是随机的。

这是因为并发执行的进程可能会同时占用CPU，导致打印顺序的不确定性。

3. 实验三：使用signal()捕捉键盘中断信号，并通过kill()向子进程发送信号在实验三中，我们使用signal()捕捉键盘中断信号（按c键），然后通过kill()向两个子进程发送信号，实现进程的终止。

实验结果显示，当按下c键时，两个子进程被终止，而父进程继续执行。

这表明signal()和kill()在进程控制方面具有重要作用。

4. 实验四：分析利用软中断通信实现进程同步的机理在实验四中，我们分析了利用软中断通信实现进程同步的机理。

一、实验背景与目的随着计算机技术的发展，多任务处理和多进程并发已经成为操作系统设计中的基本要求。

为了更好地理解进程并发的基本原理和实现方法，我们进行了本次实验。

实验的目的是通过实践操作，加深对进程并发执行的理解，掌握进程创建、同步、互斥等基本概念，并学会使用相关系统调用实现进程的并发控制。

二、实验环境与工具实验环境：Windows 10操作系统，Visual Studio 2019开发环境。

实验工具：C++编程语言，WinAPI系统调用。

三、实验内容与步骤本次实验主要分为以下几个部分：1. 进程创建与并发执行- 使用CreateProcess函数创建多个进程，并观察它们的并发执行情况。

- 使用GetTickCount函数获取每个进程的执行时间，分析并发执行的效果。

2. 进程同步- 使用互斥锁（mutex）实现进程间的同步，确保同一时刻只有一个进程访问共享资源。

- 使用条件变量（condition variable）实现进程间的条件同步，实现生产者-消费者模型。

3. 进程互斥- 使用信号量（semaphore）实现进程间的互斥，避免资源竞争。

- 使用临界区（critical section）保护共享资源，防止多个进程同时访问。

4. 实验分析- 分析实验结果，总结进程并发、同步和互斥的原理和方法。

- 讨论实验中遇到的问题和解决方法。

四、实验代码示例以下是一个简单的实验代码示例，演示了使用互斥锁实现进程同步的过程：```cpp#include <windows.h>#include <iostream>using namespace std;// 全局互斥锁mutex mtx;void processFunction(){unique_lock<mutex> lock(mtx);cout << "Process " << GetCurrentProcessId() << " is running." << endl;lock.unlock();}int main(){// 创建两个进程CreateProcess(NULL, "process.exe", NULL, NULL, FALSE, 0, NULL, NULL, NULL, NULL);// 主进程继续执行cout << "Main process is running." << endl;return 0;}```五、实验结果与分析1. 进程创建与并发执行通过实验，我们观察到多个进程可以并发执行，并且每个进程的执行时间都会有所不同。

操作系统实验之进程管理实验报告一、实验目的本次操作系统实验的主要目的是深入理解进程管理的概念和原理，通过实际操作和观察，掌握进程的创建、调度、同步与互斥等关键机制。

二、实验环境本次实验使用的操作系统为 Windows 10，开发工具为 Visual Studio 2019，编程语言为 C+＋。

三、实验内容1、进程创建使用系统提供的 API 函数创建新的进程。

观察新进程的资源使用情况和运行状态。

2、进程调度编写程序模拟不同的进程调度算法，如先来先服务（FCFS）、短作业优先（SJF）和时间片轮转（RR）。

比较不同调度算法下的平均周转时间、平均等待时间等性能指标。

3、进程同步与互斥利用信号量、互斥锁等机制实现进程之间的同步与互斥。

设计并发程序，解决生产者消费者问题、读写者问题等经典同步问题。

四、实验步骤1、进程创建实验首先，包含所需的头文件，如｀＜windowsh>｀。

然后，定义创建进程的函数，使用｀CreateProcess` 函数创建新进程，并获取进程的相关信息，如进程标识符、线程标识符等。

最后，通过查看任务管理器或其他系统工具，观察新创建进程的资源占用情况。

2、进程调度实验设计不同的调度算法函数，如｀FCFSSchedule`、｀SJFSchedule` 和｀RRSchedule`。

在每个调度算法函数中，模拟进程的到达时间、服务时间等参数，并按照相应的算法进行进程调度。

计算每个进程的周转时间和等待时间，并求出平均周转时间和平均等待时间。

3、进程同步与互斥实验定义信号量或互斥锁变量。

在生产者消费者问题中，生产者在生产产品时获取互斥锁，生产完成后释放互斥锁并通知消费者；消费者在消费产品时获取互斥锁，消费完成后释放互斥锁。

在读写者问题中，读者在读取数据时获取共享锁，读完后释放共享锁；写者在写入数据时获取独占锁，写入完成后释放独占锁。

五、实验结果与分析1、进程创建实验结果成功创建新的进程，并能够获取到进程的相关信息。

进程创建实验报告第一篇：进程创建实验报告实验二进程的创建一、实验目的熟悉进程的创建过程，了解系统调用函数fork()和 execl()。

二、实验内容1、阅读实例代码fork1，并编辑、编译、运行，记录程序的运行结果，尝试给出合理的解释，查阅有关资料，掌握系统调用fork()的用法，返回值的意义。

2、阅读实例代码fork2，并编辑、编译、运行，记录程序的运行结果，尝试给出合理的解释，查阅有关资料，掌握在程序中运行一个操作系统命令和运行一个程序的方法。

3、修改fork2，使之能把运行的命令和程序作为参数传给fork2。

三、设计思想1、程序框架pid =-1 pid = 0 pid > 02、用到的文件系统调用函数 fork()和 execl()四、调试过程1、测试数据设计（1）fork1 命名程序1：编写程序1：编译程序1：运行程序1：(2)fork2 编写程序2：运行程序2：(3)修改fork2 编写修改程序2：修改后的运行结果：2、测试结果分析（1）对于程序1：因为系统调用fork()函数是一次调用两次返回值，而且先生成子进程还是父进程是不确定的，所以第一次执行生成子进程的时候返回的pid = 0，判断pid!=-1，所以输出了I’m the child.I’m the parent.第二次，执行父进程的时候，返回的是子进程的进程号pid > 0，即pid的值仍然不为-1，所以又输出了一次I’m the child.I’m the parent。

（2）对于程序2：第一次调用fork()函数时，由于执行的是子进程还是父进程是随机的，所以第一次对父进程返回的是子进程的进程号（大于0），即pid > 0，所以输出I’m the parent.Program end.当第二次执行子进程时返回值是0，即pid = 0，所以输出I’m the child.并调用了execl()函数，查看了指定路径中的文件。

实验一：进程创建、并发执行实验目的 加强对进程概念的理解 进一步了解并发执行的实质实验内容函数创建子进程。

函数创建的子进程与父进程之间的同名变量是否为临界资源。

函数编写一个程序，要求父进程创建两个子进程，父进程、子进程并发 执行，输出并发执行的消息。

实验环境PC + Linux Red Hat 操作系统 GCCfork()功能：创建一个新的进程语法： #include <unistd.h>#include <sys/types.h>pid_t fork();说明：本系统调用为调用进程(也称父进程)创建一子进程。

事实上，子进程是父进程 的一个 “复制品 ”。

父子进程为独立进程，平等调度，用户空间独立 。

返回值：调用成功，则返回两次。

对子进程返回 0，对父进程返回子进程号，这也是最 方便的区分父子进程的方法。

调用失败则返回 -1 给父进程，子进程不生成 杀死执行中的进程 #include <sys/types.h> #include <signal.h> void kill(pid_t pid,int signo); pid 为要被杀死的进程 id,signo 可以置为 SIGINT 或 SIGTERM 。

stat_loc 带回子进程的五、 流程图 利用 fork()考察 fork()利用 fork() 1、 2、 3、 四、实验原理及实验思路kill() 功能：语说明： 返回值：等待到一个子进程返回时，返回值为该子进程号，同时 返回状态信息(参考 exit )。

若无子进程，则返回值为 -1。

z Ii六、源代码Lab1-1 ：#include <unistd.h> #include <sys/types.h> #include <stdio.h> main(){pid_t child;printf( “ Forking\n..".);child =fork();if (child<0){perror("Fork failed!\n"); exit(1);}else if (child==0){printf("I'm the child!\n");}else{printf("I'm the parent!\n");}printf("Why I'm printed twice??\n"); }Lab1-2 ：#include <unistd.h>#include <sys/types.h>#include <stdio.h>main(){pid_t child;int a=0;printf("Forking...\n"); child=fork();if (child<0){perror("Fork failed!\n"); exit(1);}else if (child==0){a++; printf("Child:a=%d\n",a);}else{a++;printf("Parent:a=%d\n",a);}}Lab1-3 ：#include "unistd.h"#include "sys/types.h"#include "signal.h"#include "stdio.h" int main(int argc,char* argv[]) {pid_t child1_pid,child2_pid;int i = 15;/*fork*/printf("first fork\n");child1_pid = fork(); if(child1_pid < 0){printf("fork() fail!\n");return -1;}else if(child1_pid == 0){printf("this is the first child process \n"); while(1){sleep(1);printf("the first child proc waiting to be killed\n"); } }else{printf("this is farther process, after first fork\n"); }/*fork*/ printf("second fork\n"); child2_pid = fork(); if(child2_pid < 0) {printf("fork() fail!\n");return -1;}else if(child2_pid == 0){printf("this is the second child process \n"); while(1){sleep(1);printf("the second child proc waiting to be killed\n"); }} else{printf("this is farther process, after second fork\n");}while(i > 0){printf("after %d second,all proc will be killed\n",i); sleep(2);i -= 2; } /*kill*/ printf("kill the first child proc\n");kill(child1_pid,SIGINT); printf("kill the second child proc\n"); kill(child2_pid,SIGINT); return 0;七、运行结果及其分析Lab1-1 ：输出：Forking... I'mthe child!八、Lab1-2 ：输出：Lab1-3 ：输出：Why I'm printed twice??Forking...Child a1first forkthis is the first child processthe first child proc waiting to be killedthis is the second child process this isfarther process, after second fork 实验总结加强了对进程概念的理解，进一步了解了并发执行的实质。

第1篇一、实验目的1. 理解进程的概念和进程创建的基本原理。

2. 掌握使用C语言模拟进程创建的方法。

3. 熟悉进程的属性和进程之间的通信机制。

4. 分析实验结果，加深对进程管理的理解。

二、实验环境1. 操作系统：Windows 102. 编程语言：C语言3. 开发环境：Visual Studio 2019三、实验原理进程是计算机中程序执行的基本单位，是操作系统进行资源分配和调度的一个独立单位。

进程创建是操作系统的一个重要功能，它负责为进程分配必要的资源，并建立进程控制块（PCB）。

在模拟进程创建实验中，我们将使用C语言编写程序，模拟进程的创建、运行和销毁过程。

通过模拟进程的创建，我们可以了解进程的基本属性，如进程ID、进程状态、父进程ID等。

四、实验步骤1. 定义进程结构体，包含进程的基本属性，如进程ID、进程状态、父进程ID等。

```ctypedef struct {int pid; // 进程IDint state; // 进程状态int parent_pid; // 父进程ID// 其他属性} Process;```2. 编写进程创建函数，用于创建新进程。

```cProcess create_process(int parent_pid) {Process new_process;new_process.pid = ...; // 分配进程IDnew_process.state = ...; // 设置进程状态 new_process.parent_pid = parent_pid;// 设置其他属性return new_process;}```3. 编写进程运行函数，用于模拟进程的运行过程。

```cvoid run_process(Process p) {// 模拟进程运行过程// ...}```4. 编写进程销毁函数，用于销毁进程。

```cvoid destroy_process(Process p) {// 销毁进程资源// ...}```5. 编写主函数，模拟进程创建、运行和销毁过程。

一、实验目的1. 理解进程的概念及其在操作系统中扮演的角色。

2. 掌握进程创建的基本原理和过程。

3. 学习使用编程语言实现进程的创建和基本管理。

二、实验环境1. 操作系统：Windows 102. 编程语言：C语言3. 开发环境：Visual Studio 2019三、实验原理进程是操作系统中执行的基本单元，是系统进行资源分配和调度的基本单位。

进程创建是指操作系统创建一个新的进程，使其从无到有，成为系统中的一个可执行实体。

进程创建的基本原理如下：1. 系统为进程分配必要的资源，如内存、CPU时间等。

2. 创建进程控制块（PCB），记录进程的基本信息。

3. 将进程插入到进程队列中，等待调度。

四、实验内容1. 创建一个名为“HelloWorld”的进程，该进程在执行时打印“Hello, World!”。

2. 研究进程创建的过程，分析进程控制块（PCB）的结构。

3. 使用编程实现进程的创建、调度和销毁。

五、实验步骤1. 创建一个新的C语言项目，命名为“进程创建实验”。

2. 在主函数中，使用系统调用创建一个新的进程。

3. 编写进程函数，实现打印“Hello, World!”的功能。

4. 编写进程的调度函数，实现进程的创建、调度和销毁。

5. 编译并运行程序，观察进程创建和执行过程。

六、实验代码```c#include <stdio.h>#include <stdlib.h>#include <unistd.h>// 进程函数void processFunc() {printf("Hello, World!\n");}int main() {pid_t pid;pid = fork(); // 创建子进程if (pid == -1) {// 创建进程失败perror("fork");exit(1);} else if (pid == 0) {// 子进程processFunc();exit(0);} else {// 父进程wait(NULL); // 等待子进程结束printf("子进程结束，PID：%d\n", pid);}return 0;}```七、实验结果与分析1. 编译并运行程序，观察进程创建和执行过程。

一、实验目的1. 理解进程的基本概念和进程控制块（PCB）的作用。

2. 掌握进程创建、调度、同步和通信的基本方法。

3. 熟悉进程状态转换及进程同步机制。

4. 提高编程能力，加深对操作系统进程管理的理解。

二、实验环境1. 操作系统：Windows 102. 编程语言：C/C++3. 开发环境：Visual Studio 2019三、实验内容1. 进程创建与销毁2. 进程调度3. 进程同步4. 进程通信四、实验步骤1. 进程创建与销毁（1）定义进程结构体```ctypedef struct {int pid; // 进程IDchar name[50]; // 进程名int status; // 进程状态struct PCB next; // 指向下一个进程的指针} PCB;```（2）创建进程```cPCB createProcess(char name) {PCB newProcess = (PCB )malloc(sizeof(PCB)); newProcess->pid = ...; // 分配进程IDstrcpy(newProcess->name, name);newProcess->status = ...; // 初始化进程状态 newProcess->next = NULL;// ... 其他初始化操作return newProcess;}```（3）销毁进程```cvoid destroyProcess(PCB process) {free(process);}```2. 进程调度（1）定义进程队列```ctypedef struct {PCB head; // 队列头指针PCB tail; // 队列尾指针} ProcessQueue;```（2）初始化进程队列```cvoid initProcessQueue(ProcessQueue queue) {queue->head = NULL;queue->tail = NULL;}```（3）入队```cvoid enqueue(ProcessQueue queue, PCB process) { if (queue->head == NULL) {queue->head = process;queue->tail = process;} else {queue->tail->next = process;queue->tail = process;}}（4）出队```cPCB dequeue(ProcessQueue queue) {if (queue->head == NULL) {return NULL;}PCB process = queue->head;queue->head = queue->head->next; if (queue->head == NULL) {queue->tail = NULL;}return process;}```3. 进程同步（1）互斥锁```ctypedef struct {int locked; // 锁的状态} Mutex;void initMutex(Mutex mutex) {mutex->locked = 0;void lock(Mutex mutex) {while (mutex->locked) {// 等待锁释放}mutex->locked = 1;}void unlock(Mutex mutex) {mutex->locked = 0;}```（2）信号量```ctypedef struct {int count; // 信号量值Mutex mutex; // 互斥锁} Semaphore;void initSemaphore(Semaphore semaphore, int count) { semaphore->count = count;initMutex(&semaphore->mutex);}void P(Semaphore semaphore) {lock(&semaphore->mutex);while (semaphore->count <= 0) {// 等待信号量}semaphore->count--;unlock(&semaphore->mutex);}void V(Semaphore semaphore) {lock(&semaphore->mutex);semaphore->count++;unlock(&semaphore->mutex);}```4. 进程通信（1）管道通信```cint pipe(int pipefd[2]) {// 创建管道}void writePipe(int pipefd[2], const void buf, size_t nbyte) { // 向管道写入数据}void readPipe(int pipefd[2], void buf, size_t nbyte) {// 从管道读取数据}```（2）消息队列通信```cint msgget(key_t key, int msgflg) {// 创建消息队列}void msgsnd(int msqid, const void msgp, size_t msgsz, int msgflg) {// 向消息队列发送消息}void msgrcv(int msqid, void msgp, size_t msgsz, long msgtype, int msgflg) {// 从消息队列接收消息}```五、实验结果与分析1. 进程创建与销毁：通过创建和销毁进程，验证了进程结构体的正确性。

进程创建模拟实验报告
一．实验目的
1.加深对进程概念的理解，明确进程和程序的区别。

2.深入了解系统如何组织进程，创建进程。

3.掌握进程相关数据结构。

二．实验要求
1.编写程序完成实验内容
2.对测试数据进行分析
3.撰写实验报告
三．实验内容
1.进程的创建
2.对代码进行测试
3.进程控制
四．实验原理
1.进程
（1）进程是程序是一次执行
（2）进程是一个程序及其数据在处理机上顺序执行时所发生的活动（3）进程是程序在一个数据集合上运行的过程，它是系统进行资源分配和调度的一个独立单位
2.进程控制块
为了描述和控制进程的运行，系统为每个进程定义了一个进程控制块（PCB），它是进程实体的一部分，是操作系统管理进程最重要
的数据结构。

其主要包含四类信息：进程标识符，处理机状态，进程调度信息，进程控制信息。

3.进程创建流程
（1）申请空白PCB
（2）为新进程分配资源
（3）初始化进程控制块
（4）将新进程插入就绪队列
4.进程树
P1
P2 P3 P4 P5
P6 P7 P8 P9 P10 P11
P12
五．实验步骤
1.在C++环境下输入实验提供的代码，并对程序运行
2.输入createpc 命令创建进程，输入showdetail 显示每个进程及其子进程的信息
3.对代码进行测试
六．实验总结
1.运行结果
2.解释函数
3.问题解答。

一、实验目的1. 理解进程的概念和特点。

2. 掌握创建进程的方法和过程。

3. 熟悉进程调度和同步机制。

4. 分析进程创建过程中可能遇到的问题及解决方法。

二、实验环境1. 操作系统：Windows 102. 编程语言：C/C++3. 开发工具：Visual Studio 2019三、实验原理进程是操作系统中进行资源分配和调度的基本单位。

创建进程是操作系统提供的一项基本功能，它允许用户在系统中启动新的程序。

在创建进程的过程中，操作系统会为进程分配一定的资源，如内存、文件句柄等。

四、实验内容1. 创建进程2. 父子进程的同步3. 进程的终止五、实验步骤1. 创建进程（1）编写C/C++程序，使用系统调用创建进程。

（2）父进程调用`fork()`函数创建子进程。

（3）在子进程中执行特定任务。

（4）父进程和子进程分别调用`wait()`函数等待对方结束。

2. 父子进程的同步（1）父进程和子进程使用信号量实现同步。

（2）父进程调用`sem_wait()`函数等待信号量。

（3）子进程调用`sem_post()`函数释放信号量。

3. 进程的终止（1）父进程调用`kill()`函数终止子进程。

（2）子进程调用`exit()`函数结束进程。

六、实验结果与分析1. 创建进程（1）在父进程中调用`fork()`函数创建子进程。

（2）父进程和子进程分别输出“父进程”和“子进程”信息。

实验结果：```父进程子进程```2. 父子进程的同步（1）父进程和子进程使用信号量实现同步。

（2）父进程调用`sem_wait()`函数等待信号量。

（3）子进程调用`sem_post()`函数释放信号量。

实验结果：```父进程子进程```3. 进程的终止（1）父进程调用`kill()`函数终止子进程。

（2）子进程调用`exit()`函数结束进程。

实验结果：```父进程子进程```七、实验总结通过本次实验，我们掌握了以下内容：1. 进程的概念和特点。