实验4 进程控制实验

一、实验目的本次实验旨在通过Linux操作系统的实践操作，加深对进程控制概念的理解。

通过学习进程的创建、调度、同步、通信等基本操作，掌握进程控制的基本方法，并了解进程间通信的机制。

二、实验环境1. 硬件环境：Intel(R) Core(TM) i5-3210M CPU2.50GHz，4.00GB内存。

2. 软件环境：64位Linux操作系统。

三、实验内容1. 进程的创建与终止2. 进程的调度与优先级3. 进程同步与互斥4. 进程间通信四、实验步骤1. 进程的创建与终止（1）使用`fork()`函数创建子进程，通过比较返回值判断创建是否成功。

```cpid_t pid = fork();if (pid < 0) {perror("fork failed");exit(1);}```（2）使用`exit()`函数终止进程。

```cexit(0);```2. 进程的调度与优先级（1）使用`nice()`函数调整进程优先级。

```cnice(10); // 降低进程优先级```（2）使用`priority_seta()`函数设置进程优先级。

```cstruct sched_param param;param.sched_priority = 10;if (sched_setscheduler(pid, SCHED_RR, &param) == -1) { perror("sched_setscheduler failed");exit(1);}```3. 进程同步与互斥（1）使用`semaphore_t`类型的信号量实现进程同步。

```csemaphore_t sem;sem_init(&sem, 0, 1);sem_wait(&sem);// 执行临界区代码sem_post(&sem);sem_destroy(&sem);```（2）使用`mutex_t`类型的互斥锁实现进程互斥。

操作系统进程控制实验报告硬件环境：处理器：Intel(R) Core(TM) i5-3210M CPU @2.50GHz 2.50GHz安装内存：4.00GB系统类型：64位操作系统软件环境：Linux系统一、实验目的加深对于进程并发执行概念的理解。

实践并发进程的创建和控制方法。

观察和体验进程的动态特性。

进一步理解进程生命期期间创建、变换、撤销状态变换的过程。

掌握进程控制的方法，了解父子进程间的控制和协作关系。

练习Linux系统中进程创建与控制有关的系统调用的编程和调试技术。

二、实验步骤（1）分析实例实验（2）进行独立实验（3）思考并完成实验报告实验截图：思考：说明它们反映出操作系统教材中进程及处理机管理一节讲解的进程的哪些特征和功能？在真实的操作系统中它是怎样实现和反映出教材中讲解的进程的生命期、进程的实体和进程状态控制的。

你对于进程概念和并发概念有哪些新的理解和认识？子进程是如何创建和执行新程序的？信号的机理是什么？怎样利用信号实现进程控制？根据实验程序、调试过程和结果分析写出实验报告。

1.进程的概念：进程不仅是一段程序代码，还包括当前活动(通过程序计数器和寄存器中的内容来表示)，另外，进程还包括进程堆栈段，和数据段等。

2.并发概念：是指进程之间交替并发执行3.进程通过系统调用fork（）函数创建子进程，子进程由唯一的pid值标示，pid通常是一个整数值。

通过fork创建的子进程实际上是父进程的克隆体，通过复制原来进程的地址空间而成，父子进程同时执行fork之后的程序。

但是父子进程的pid值不同，可以通过对pid的判断，使父子进程执行不同的程序。

子进程如果想执行不同的程序，需要系统调用exec（）函数装入新的程序执行。

4.信号的机理：信号是用来通知进程某个特定的事件已经发生。

信号是由特定的事件产生，信号必须要发送到进程，一旦发送，进程必须得到处理。

信号可以可以有系统默认处理也可以用户自定义处理。

测试过程: （实验中出现的问题、错误、解决方法）创建好项目和文件, 对文件进行编译和运行, 编译没有错误, 但是运行总是提示有2个错误。

解决办法：在新建项目的时候“新建”, 然后新建文件, 程序就可以正常的运行了。

实验总结:1、课下没有对Microsoft Visual c++ 6.0进行深入的研究, 还是好多问题不知道怎么解决, 好好钻研一下这个很有必要的啊!评语与成绩:教师签名:年月日实验名称进程控制实验类型验证性实验时间实验环境Windows xp 、Microsoft Visual c++ 6.0实验目的与要求:1．通过创建进程、观察正在运行的进程和终止进程的程序设计和调试操作, 进一步熟悉操作系统的进程概念, 理解Windows 2000进程的“一生”。

2.通过阅读和分析实验程序，学习创建进程、观察进程和终止进程的程序设计方法。

实验内容:本实验给出了三段程序：创建进程、正在运行的进程和终止进程, 阅读程序回答所提问题, 分析运行结果。

一、实验步骤: （算法描述、源程序、操作步骤和方法）二、创建进程回答问题:1.该程序是一个简单使用CreateProcess（）API函数的例子。

首先形成简单的命令行, 提供当前EXE文件的指定文件名和代表生成克隆进程的号码。

大多数参数都可取默认值, 但是创建标志参数使用了CREATE_NEW_CONSOLE标志, 指示新进程分配自己的控制台, 这使得运行程序时, 在任务栏上产生许多活动标记。

然后该克隆进程的创建方法关闭传递过来的句柄并返回main （）函数。

在关闭程序之前, 每一进程的执行主线程暂停一下, 以便让用户看到其中的至少一个窗口。

2、CreateProcess（）函数有几个核心参数？本实验程序中设置的各个参数的值是什么？答、CreateProcess（）函数有10个核心参数参数的值为: CreateProcess(szFilename, //产生这个EXE的应用程序的名称szCmdLine, //告诉其行为像一个子进程的标志NULL, //缺省的进程安全性NULL, //缺省的线程安全性FALSE, //不继承句柄CREATE_NEW_CONSOLE, //使用新的控制台NULL, //新的环境NULL, //当前目录&si, //启动信息&pi);3.程序运行时屏幕显示的信息是什么？答、三、运行进程1、回答问题:2、给出运行结果（当前PID信息、操作系统版本、系统提示信息）答、运行结果为:2.如何获得当前的PID和操作系统版本可利用GetCurrentProcessId()API函数查看系统当前进程的标识符（pid）, 该pid在整个系统中都可使用。

操作系统进程控制实验报告分析解析
本次实验的目的是通过自己编写一个简单的操作系统内核来深入了解操作系统进程控
制的机制。

实验采用的是汇编语言和C语言相结合的方式进行编写，在这个过程中我们首先要学
会如何引导操作系统进入内核，然后再进行进程的创建和控制。

在内核的启动阶段，我们需要自己编写汇编代码来实现操作系统内核运行的基本步骤。

在这个过程中，我们需要构造一个启动扇区来引导内核的运行。

在这个启动扇区中，我们
需要编写一些汇编代码来初始化段描述符，并将段选择符加载到寄存器中，最后将控制权
转移到C代码中进一步执行。

在内核运行的过程中，我们需要进行进程的创建和控制。

在这个过程中，我们需要以
某种方式来实现进程的调度，以保证系统的稳定和高效。

在本次实验中，我们采用了基于
时间片的轮转调度算法来实现进程的调度。

通过这个调度算法，我们可以实现进程的快速
切换，从而增强了系统的响应速度和稳定性。

最后，在本次实验中，我们还需要学会如何进行进程的同步和通信。

在这个过程中，
我们可以使用信号量机制来实现进程之间的同步和通信。

通过这个机制，我们可以定义一
些信号量，然后让进程在访问共享资源时进行加锁和解锁，从而实现对共享资源的互斥访问。

总之，通过本次实验，我们深入了解了操作系统进程控制的机制，学会了如何编写一
个简单的操作系统内核，以及如何进行进程的创建和控制。

通过这个实验，我们对操作系
统的理解更加深入，对于进一步学习操作系统原理和实现方法，具有很大的帮助作用。

第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. 实验四：分析利用软中断通信实现进程同步的机理在实验四中，我们分析了利用软中断通信实现进程同步的机理。

进程控制与进程通信程序实验报告一、引言进程是计算机系统中最基本的概念之一，是操作系统中最小的资源管理单位。

进程控制与进程通信是操作系统中重要的内容，涉及到进程的创建、调度和终止，以及进程间的信息传递和同步管理。

本实验旨在通过编写进程控制与进程通信程序，加深对操作系统中进程管理和通信机制的理解。

二、实验目的1. 理解进程的概念和特点，掌握进程的创建、调度和终止方法。

2. 掌握进程通信的基本原理和方法，包括共享内存、管道、消息队列和信号量等。

3. 能够编写简单的进程控制和进程通信程序。

三、实验内容1. 进程控制实验：编写一个程序，实现进程的创建、调度和终止。

通过调用系统调用函数，创建多个子进程，并通过进程控制函数实现父子进程的协作与同步。

2. 进程通信实验：编写一个程序，实现进程间的信息传递和同步管理。

通过共享内存、管道、消息队列或信号量等机制，实现不同进程之间的数据交换和共享。

四、实验步骤1. 进程控制实验：（1）创建父进程和子进程：使用fork()函数创建子进程，并通过判断返回值来区分父子进程。

（2）调度子进程：使用wait()函数等待子进程的结束，以实现父子进程的同步。

（3）终止子进程：使用exit()函数终止子进程的运行。

2. 进程通信实验：（1）共享内存：使用shmget()函数创建共享内存段，使用shmat()函数映射共享内存到进程的地址空间，实现共享数据的读写。

（2）管道：使用pipe()函数创建管道，使用fork()函数创建子进程，通过读写管道实现进程间的数据传输。

（3）消息队列：使用msgget()函数创建消息队列，使用msgsnd()函数向消息队列发送消息，使用msgrcv()函数从消息队列接收消息，实现进程间的消息传递。

（4）信号量：使用semget()函数创建信号量，使用semop()函数对信号量进行P操作和V操作，实现进程间的同步和互斥。

五、实验结果通过实验，我们成功实现了进程的创建、调度和终止，以及进程间的信息传递和同步管理。

操作系统实验报告实验题目：进程控制专业计算机科学与技术学生姓名班级学号 12006715 指导教师指导单位计算机学院日期 2014年11月13日一、实验目的1.学习和了解进程控制的基本和常用的系统调用fork wait sleep exit exec等等2. 查看 /usr/src/include/sched.h中的task_struct 数据结构，并分析Linux 操作系统进程状态。

3.通过进程创建的应用实例，深刻理解进程创建的过程将以下例题输入运行，并分析运行结果程序例题1#include <stdio.h>#include <sys/types.h>#include <unistd.h>int main(void){pid_t pid;int data=5;if((pid=fork())<0){printf("fork error\n");exit(0);}else if(pid==0){data--;printf("child\'s data is:%d\n",data);exit(0);}else{printf("parent\'s data is:%d\n",data);}exit(0);}程序例题2用fork创建一个子进程，由其调用execve启动shell命令ps查看系统当前的进程信息#include <stdio.h>#include <sys/types.h>#include <unistd.h>main( ){pid_t pid;char *path="/bin/ps";char *argv[5]={ "ps","-a","-x",NULL};printf(“Run ps with execve by child process:\n”);if((pid=fork( ))<0){printf(“fork error!”);exit(0);}else if (pid==0){if(execve(path,argv,0)<0){printf(“fork error!”);exit(0);}printf(“child is ok!\n”);exit(0);}wait( );printf(“it is ok!\n”);exit(0);}3.创建一个共享内存，实现一个生产者进程写共享内存，一个消费者进程读共享内存，并在写前读后输出写和读的内容。

过程控制实验报告实验目的：1.理解进程控制的基本概念和原理；2.掌握进程调度算法的原理和实现方式；3.掌握进程间通信的方法和实现方式。

实验仪器和材料：1.计算机；2. 操作系统（Windows、Linux等）；3.编程语言C或C++。

实验过程：在操作系统的支持下，实现了一个简单的进程调度和通信的模拟程序。

1.进程的创建和管理通过调用操作系统提供的系统调用函数，实现进程的创建和管理。

首先，编写一个创建进程的函数createProcess，该函数通过调用系统调用函数fork创建一个新的进程，并通过调用系统调用函数exec加载并执行一个可执行文件。

创建的进程可以通过调用系统调用函数wait等待其他进程的结束，并通过调用系统调用函数exit退出当前进程。

2.进程调度算法实现了三种常见的进程调度算法：先来先服务（FCFS）、最短作业优先（SJF）和时间片轮转算法（RR）。

首先，编写一个函数schedule，该函数根据调度算法从就绪队列中选择一个进程，并调用操作系统提供的系统调用函数进行进程切换。

调度算法的选择通过用户输入进行控制。

3.进程间通信实现了两种常见的进程间通信方法：管道和共享内存。

首先，编写一个函数createPipe，该函数通过调用系统调用函数pipe创建一个管道，用于实现进程间的通信。

然后，编写一个函数createSharedMemory，该函数通过调用系统调用函数shmget创建一块共享内存，用于实现进程间的共享数据。

实验结果：在实验过程中，使用C语言编写了一个模拟进程调度和通信的程序。

通过调用系统调用函数，在操作系统的支持下，成功实现了进程的创建和管理、进程调度算法的实现以及进程间通信的功能。

实验结果显示，不同的进程调度算法对进程执行的顺序和时间有不同的影响；而进程间通信的方法可以实现进程之间的数据交换和共享。

实验总结：通过本次实验，理解了进程控制的基本概念和原理，掌握了进程调度算法和进程间通信的实现方法。

《操作系统原理》实验报告
实验序号：4 实验项目名称：进程控制
一、实验目的及要求
1. 加深对进程信号量的理解。

2. 理解进程同步与互斥机制。

3. 掌握Linux操作系统下的进程控制编程。

二、实验设备（环境）及要求
1.虚拟机VMware Workstation、Ubuntu操作系统和C语言编程。

2.编写一段程序，使用系统调用fork()创建两个子进程，再用系统调用signal()让父进程捕捉键盘上来的中断信号（即按Ctrl C键），当捕捉到中断信号后，父进程调用kill()向两个子进程发出信号，子进程捕捉到信号后，分别输出下面信息后终止：
child process 1 is killed by parent!
child process 2 is killed by parent!
父进程等待两个子进程终止后，输出以下信息后终止：
parent process is killed!
三、实验内容与步骤
代码：
在终端上进行测试
四、实验结果与数据处理
五、分析与讨论
了解了计算机进程的管理以及signal（）函数的作用。

六、教师评语成绩。

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

2. 进一步认识并发执行的实质，理解进程的创建、调度、同步与通信。

3. 学习使用Linux系统中的进程管理命令，掌握进程的监控、控制与优化。

二、实验环境操作系统：Linux Ubuntu 20.04实验工具：终端（Terminal）、shell命令三、实验内容1. 进程的基本概念与特性2. 进程的创建与调度3. 进程同步与通信4. 进程的监控与优化四、实验步骤1. 进程的基本概念与特性（1）通过阅读相关资料，了解进程的概念、特性和生命周期。

（2）使用shell命令查看当前系统中进程的状态，如ps、top、htop等。

2. 进程的创建与调度（1）使用fork()函数创建进程，观察父子进程之间的关系。

（2）使用exec()函数替换子进程的映像，实现进程的创建。

（3）使用wait()、waitpid()等函数等待子进程结束，控制进程执行顺序。

（4）通过修改进程优先级，观察进程调度策略的变化。

3. 进程同步与通信（1）使用互斥锁（mutex）实现进程同步，防止数据竞争。

（2）使用条件变量（condition variable）实现进程间的条件同步。

（3）使用信号量（semaphore）实现进程间的同步与通信。

（4）通过管道（pipe）、消息队列（message queue）、共享内存（shared memory）等机制实现进程间的通信。

4. 进程的监控与优化（1）使用ps、top、htop等命令监控进程的运行状态。

（2）通过调整进程优先级，优化进程的执行顺序。

（3）使用renice命令调整进程的实时性。

（4）使用nice命令调整进程的调度策略。

五、实验结果与分析1. 进程的基本概念与特性通过实验，我们了解到进程是具有一定独立功能的程序关于某个数据集合的一次运行活动，具有并发性、动态性、独立性、异步性和结构特征等特性。

2. 进程的创建与调度实验过程中，我们成功创建了多个进程，并通过修改进程优先级，观察到调度策略的变化。

进程控制与进程通信程序实验报告1. 背景进程控制与进程通信是操作系统的重要概念之一，它们在现代计算机系统中起到了至关重要的作用。

进程控制是指操作系统对进程的创建、执行、中止和切换等各种操作的管理和控制，进程通信则是指进程之间通过各种方式传递信息和实现协作的机制。

在本次实验中，我们需要编写一个进程控制与进程通信程序。

通过实现进程的创建、执行和中止等基本操作，并通过进程通信机制进行信息传递，实现多个进程之间的协作。

本实验将帮助我们进一步理解和掌握进程控制与进程通信的原理和操作。

2. 分析2.1 实验要求本次实验要求我们编写一个进程控制与进程通信程序，实现以下功能：1.创建一个主进程和多个子进程，并实现进程的执行和切换；2.子进程之间通过进程通信机制传递信息；3.实现多个子进程之间的协作，完成指定的任务。

2.2 系统设计为了满足实验的要求，我们可以按照以下步骤设计我们的系统：1.创建主进程和多个子进程：使用操作系统提供的进程创建函数，创建一个主进程和多个子进程。

主进程将负责协调子进程的执行和协作。

2.进程执行和切换：使用操作系统提供的进程执行和切换函数，实现进程的执行和切换操作。

主进程可以通过改变进程的状态和优先级来控制进程的执行和切换。

3.进程通信机制：使用操作系统提供的进程通信机制，如消息队列、共享内存等，实现子进程之间的信息传递。

可以定义统一的消息格式，并使用相应的函数进行消息的发送和接收。

4.进程协作：根据实验要求，设计子进程之间的协作方式。

可以使用信号量、条件变量等机制来实现多个子进程之间的同步和互斥。

2.3 实验结果实验的结果将是一个能够创建多个子进程，并通过进程通信进行协作的程序。

程序将实现以下功能：1.主进程创建多个子进程，并通过改变进程的状态和优先级来控制进程的执行；2.子进程通过进程通信机制传递信息，完成指定的任务；3.子进程之间通过协作实现同步和互斥，保证任务的正确执行。

3. 实验步骤3.1 创建进程首先，我们需要创建主进程和多个子进程。

进程控制实验报告进程控制实验报告一、实验目的本实验旨在通过实际操作，深入理解进程控制的概念、原理和实现方式，掌握进程控制的技巧和方法，提升解决实际问题的能力。

二、实验原理进程控制是操作系统内核的重要功能之一，它负责协调和管理系统中多个进程的执行顺序和资源分配。

进程控制的主要任务包括创建和终止进程、进程切换和进程同步等。

本实验将通过具体的操作，学习和体验进程控制的过程和细节。

三、实验步骤1.实验准备（1）了解和熟悉实验室环境，包括计算机硬件配置、操作系统版本等信息。

（2）准备实验材料，包括相关文档、软件工具等。

（3）明确实验任务和目的，制定实验计划。

2.创建进程（1）打开实验环境，启动操作系统。

（2）使用编程语言（如C语言）编写一个简单的程序，该程序将创建一个新的进程。

（3）编译并运行程序，观察和记录进程的创建过程。

3.进程切换（1）编写一个程序，该程序将在两个进程之间进行切换。

（2）运行程序，观察和记录进程切换的过程和效果。

4.进程同步（1）使用信号量或其他同步机制实现两个进程的同步。

（2）运行程序，观察和记录进程同步的过程和效果。

5.进程终止（1）编写一个程序，该程序将终止一个指定的进程。

（2）运行程序，观察和记录进程终止的过程和效果。

6.实验总结与报告编写（1）总结实验过程和结果，梳理实验中的问题和解决方法。

（2）编写实验报告，包括实验目的、原理、步骤、结果分析等。

四、实验结果与分析通过本次实验，我们成功地创建了一个新的进程，并实现了进程之间的切换、同步和终止。

在实验过程中，我们深入理解了进程控制的概念、原理和实现方式，掌握了进程控制的技巧和方法。

同时，我们也遇到了一些问题，如进程创建失败、进程切换不成功等，但通过仔细分析问题原因并采取相应的解决方法，最终成功解决了这些问题。

通过本次实验，我们不仅学到了专业知识，也提高了解决实际问题的能力。

五、实验结论与建议本次实验让我们更加深入地理解了进程控制的相关知识，并掌握了进程控制的基本操作方法。

课程名称：操作系统实验名称：进程的控制班级：092017姓名：江波同组人：___________________________指导教师评定：_____________________ 签名：__________________________一、实验目的：1.熟悉Linux环境2.知道如何在Linux环境下如何编写C语言程序3.知道如何在Linux环境下进程是如何被控制和管理的二、实验要求：在Linux环境下用记事本编写如下代码，并对其进行编译和运行，观察执行时屏幕上出现的现象，并分析其原因，然后再对代码进行适当的修改再观察执行时的现象并分析其原因。

#include <stdio.h>main (){int p1 , p2 , i;while ((p1= fork ()) < 0 ) ;if( p1 == 0 )for (i = 0 ; i< 50 ; i++)printf (“child %d\n” , i) ;else{ while (( p2 = fork ()) <0 ) ;if ( p 2 == 0 )for ( i= 0 ; i < 50 ;i++ )printf ( “son%d \n ”, I )elsefor ( i = 0 ;i < 50 ;i++ )printf (“daughter %d \n ”, i ) ;}}三、实验步骤：（1）登入Linux虚拟机。

（2）在虚拟机环境下用记事本编写上面代码，保存完之后在终端里面对它进行调试、编译和运行。

（3）观察运行结果，得出结论。

（4）再修改部分代码并调试、编译、运行观察结果。

四、实验结果：Child0Child1Child2Child4Child5Child6Child7Child8Child9...Son0Son1Son2Child3Son3Son5Son6Son7Son8Son9...Daughter0Daughter1Daughter2Son4Daughter3Daughter4Daughter5Daughter6Daughter7Daughter8Daughter9...五、实验感想：由于函数printf()输出的字符串之间不会被中断，因此，字符串内部的字符顺序输出时不变。

进程控制实验报告进程控制实验报告一、引言进程控制是操作系统中的重要概念，它涉及到进程的创建、调度、终止等方面。

本篇实验报告将介绍我们在进程控制实验中所进行的工作和实验结果。

二、实验目的本次实验的目的是通过编写程序，了解进程的创建、调度和终止过程，并掌握相关的系统调用和操作。

三、实验环境我们使用的实验环境是Linux操作系统，并使用C语言编写程序。

四、实验步骤1. 进程创建在实验中，我们编写了一个简单的程序，用于创建新的进程。

通过调用系统调用fork()，我们可以在父进程中创建一个子进程。

子进程是父进程的副本，它们共享一些资源，但有各自独立的执行空间。

2. 进程调度在实验中，我们使用了系统调用exec()来进行进程调度。

通过调用exec()，我们可以在一个进程中执行另一个可执行文件。

这样，原来的进程将被替换为新的进程，并开始执行新的程序。

3. 进程终止在实验中，我们使用了系统调用exit()来终止一个进程。

当一个进程执行完毕或者遇到错误时，可以调用exit()来结束自己的执行。

同时，exit()函数还可以传递一个整数值作为进程的返回值，供其他进程获取。

五、实验结果通过实验，我们成功地创建了多个进程，并进行了调度和终止操作。

我们观察到，创建的子进程在父进程的基础上执行，并且具有独立的执行空间。

在调度过程中，我们能够看到进程的切换和执行结果的输出。

在终止过程中，我们成功地结束了进程的执行，并获取了进程的返回值。

六、实验总结通过本次实验，我们深入了解了进程控制的相关概念和操作。

我们通过编写程序，实际操作了进程的创建、调度和终止过程。

这些实验结果对于我们理解操作系统的工作原理和进程管理机制具有重要意义。

七、实验感想本次实验让我们深刻认识到进程控制在操作系统中的重要性。

进程的创建、调度和终止是操作系统能够高效运行的基础。

通过实验，我们不仅掌握了相关的系统调用和操作，还加深了对操作系统原理的理解。

八、实验改进在实验中，我们可以进一步扩展功能，例如实现进程间的通信和同步机制。

### 实验目的1. 理解操作系统进程控制的基本概念和原理。

2. 掌握进程的创建、同步、通信和终止等操作。

3. 熟悉Linux系统中的进程控制命令和系统调用。

4. 理解进程调度算法的基本原理和实现方法。

### 实验环境1. 操作系统：Linux2. 编程语言：C/C++3. 编译器：gcc4. 开发工具：vim### 实验内容本实验主要涉及以下内容：1. 进程的创建与终止2. 进程同步与通信3. 进程调度算法#### 1. 进程的创建与终止实验一：利用fork()创建进程```c#include <stdio.h>#include <unistd.h>#include <sys/types.h>#include <sys/wait.h>int main() {pid_t pid;pid = fork();if (pid < 0) {printf("fork() error\n");return 1;} else if (pid == 0) {printf("Child process, PID: %d\n", getpid()); printf("Child process is running...\n");sleep(2);printf("Child process is exiting...\n");return 0;} else {printf("Parent process, PID: %d\n", getpid()); printf("Parent process is running...\n");sleep(3);printf("Parent process is exiting...\n");wait(NULL);}return 0;}```实验二：利用exec()创建进程```c#include <unistd.h>#include <sys/types.h>#include <sys/wait.h>int main() {pid_t pid;pid = fork();if (pid < 0) {printf("fork() error\n");return 1;} else if (pid == 0) {execlp("ls", "ls", "-l", (char )NULL); printf("execlp() error\n");return 1;} else {wait(NULL);}return 0;}```实验三：进程终止```c#include <stdio.h>#include <sys/types.h>#include <sys/wait.h>int main() {pid_t pid;pid = fork();if (pid < 0) {printf("fork() error\n");return 1;} else if (pid == 0) {printf("Child process, PID: %d\n", getpid()); sleep(2);printf("Child process is exiting...\n");exit(0);} else {wait(NULL);}return 0;}```#### 2. 进程同步与通信实验四：使用信号实现进程同步```c#include <unistd.h>#include <sys/types.h>#include <sys/wait.h>#include <signal.h>int main() {pid_t pid;int status;int signalNo = 1;pid = fork();if (pid < 0) {printf("fork() error\n");return 1;} else if (pid == 0) {printf("Child process, PID: %d\n", getpid()); while (1) {pause();printf("Child process is running...\n"); }} else {printf("Parent process, PID: %d\n", getpid()); sleep(1);kill(pid, signalNo);wait(NULL);}return 0;}```实验五：使用管道实现进程通信```c#include <stdio.h>#include <unistd.h>#include <sys/types.h>#include <sys/wait.h>int main() {int pipefd[2];pid_t pid;char buffer[100];if (pipe(pipefd) == -1) {printf("pipe() error\n"); return 1;}pid = fork();if (pid < 0) {printf("fork() error\n"); return 1;} else if (pid == 0) {close(pipefd[0]);read(pipefd[1], buffer, sizeof(buffer));printf("Child process, PID: %d, Received: %s\n", getpid(), buffer);} else {close(pipefd[1]);write(pipefd[0], "Hello, Child!\n", 14);wait(NULL);}return 0;}```#### 3. 进程调度算法实验六：先来先服务（FCFS）调度算法```c#include <stdio.h>#include <stdlib.h>#include <unistd.h>#include <sys/wait.h>#define NUM_PROCESSES 5#define TIME_QUANTUM 2typedef struct {int pid;int arrival_time;int burst_time;} Process;int main() {Process processes[NUM_PROCESSES] = {{1, 0, 5},{2, 1, 3},{3, 2, 4},{4, 3, 2},{5, 4, 1}};int i, j, time = 0, completed = 0;int wait_time[NUM_PROCESSES], turnaround_time[NUM_PROCESSES]; // Calculate waiting timefor (i = 0; i < NUM_PROCESSES; i++) {wait_time[i] = 0;}for (i = 0; i < NUM_PROCESSES; i++) {for (j = 0; j < i; j++) {wait_time[i] += processes[j].burst_time;}}// Calculate turnaround timefor (i = 0; i < NUM_PROCESSES; i++) {turnaround_time[i] = wait_time[i] + processes[i].burst_time;}// Calculate average waiting time and turnaround timeint total_wait_time = 0, total_turnaround_time = 0;for (i = 0; i < NUM_PROCESSES; i++) {total_wait_time += wait_time[i];total_turnaround_time += turnaround_time[i];}printf("Average waiting time: %.2f\n", (float)total_wait_time / NUM_PROCESSES);printf("Average turnaround time: %.2f\n",(float)total_turnaround_time / NUM_PROCESSES);return 0;}```实验七：时间片轮转调度算法```c#include <stdio.h>#include <stdlib.h>#include <unistd.h>#include <sys/wait.h>#define NUM_PROCESSES 5#define TIME_QUANTUM 2typedef struct {int pid;int arrival_time;int burst_time;} Process;int main() {Process processes[NUM_PROCESSES] = {{1, 0, 5},{2, 1, 3},{3, 2, 4},{4, 3, 2},{5, 4, 1}};int i, j, time = 0, completed = 0;int wait_time[NUM_PROCESSES], turnaround_time[NUM_PROCESSES]; // Calculate waiting timefor (i = 0; i < NUM_PROCESSES; i++) {wait_time[i] = 0;}for (i = 0; i < NUM_PROCESSES; i++) {for (j = 0; j < i; j++) {wait_time[i] += processes[j].burst_time;}}// Calculate turnaround timefor (i = 0; i < NUM_PROCESSES; i++) {turnaround_time[i] = wait_time[i] + processes[i].burst_time;}// Calculate average waiting time and turnaround timeint total_wait_time = 0, total_turnaround_time = 0;for (i = 0; i < NUM_PROCESSES; i++) {total_wait_time += wait_time[i];total_turnaround_time += turnaround_time[i];}printf("Average waiting time: %.2f\n", (float)total_wait_time / NUM_PROCESSES);printf("Average turnaround time: %.2f\n",(float)total_turnaround_time / NUM_PROCESSES);return 0;}```### 实验总结通过本次实验，我对操作系统进程控制有了更深入的了解。

一、实验目的利用Windows提供的PI函数，编写程序，实现进程的创建和终止（如创建写字板进程及终止该进程），加深对操作系统进程概念的理解，观察操作系统进程运行的动态性能，获得包含多进程的应用程序编程经验。

二、实验内容编写一个在dos界面下的简单进程控制系统，实现根据用户选项进行进程的创建、终止，并提供进程的状态。

（1）进程的创建和终止。

编写一段程序，可以创建一个进程，并终止当前创建的进程。

试观察记录程序执行的结果，并分析原因。

（2）利用VC++6.0实现上述程序设计和调试操作，对于进程创建的成功与否、终止进程操作的成功与否提供一定的提示框。

（3）通过阅读和分析实验程序，学习创建进程、观察进程和终止进程的程序设计方法三、实验步骤1.创建进程使用了Windows提供的CreteProcess函数来创建一个新的进程和它的主线程，这个新进程运行指定的可执行文件。

函数原型：BOOL CreteProcess{LPCTSTR lppplictionNme,LPTSTR lpCommndLine,LPSECURITY_TTRIBUTES lpProcessttributes。

LPSECURITY_TTRIBUTES lpThredttributes,BOOL bInheritHndles,DWORD dwCretionFlgs,LPVOID lpEnvironment,LPCTSTR lpCurrentDirectory,LPSTRTUPINFO lpStrtupInfo,LPPROCESS_INFORMTION lpProcessInformtion};一个线程调用该函数首先创建一个进程内核对象用来管理此新进程，随后系统为新进程创建虚拟地址空间，并将可执行文件的代码和数据加载到这个地址空间，接着系统为新进程的主线程创建一个线程内核对象。

本程序所使用的函数中各参数的解释：1.lppplictionNme指向一个NULL结尾的、用来指定可执行模块的字符串。

进程的管理和控制实验报告实验目的：本实验旨在了解进程的管理和控制，掌握进程的创建、终止和状态转换等操作，并通过实际的代码编写和运行实验，加深对进程管理的理解。

实验原理：在操作系统中，进程是执行中的程序的实例。

进程管理涉及到创建新进程、终止现有进程、管理进程的状态等操作。

进程的创建：进程的创建可以通过系统调用fork()来完成。

fork()系统调用会创建一个新的进程，称为子进程，子进程将继承父进程的代码、数据和资源。

通过fork()的返回值来区分父子进程，父进程返回子进程的进程ID，子进程返回0。

进程的终止：进程的终止可以通过系统调用exit()来完成。

exit()系统调用会终止当前进程的执行，并返回一个退出状态码。

一个进程的终止也可以由其他进程通过发送终止信号来实现。

进程的状态转换：进程在执行过程中会经历不同的状态，包括就绪态、运行态、阻塞态等。

进程的状态转换可以通过系统调用来实现。

例如，当进程被阻塞时，可以通过系统调用sleep()将其状态转换为阻塞态，当等待的事件发生时，再将其状态转换为就绪态。

实验步骤：1. 编写一个简单的程序，包含进程的创建、终止和状态转换等操作。

2. 使用fork()系统调用创建子进程，并在子进程中执行一段代码。

3. 在父进程中对子进程进行管理，包括等待子进程的终止和获取子进程的退出状态码。

4. 在子进程中通过exit()系统调用终止进程的执行。

5. 在父进程中通过wait()系统调用等待子进程的终止，并获取子进程的退出状态码。

6. 在子进程中通过系统调用sleep()将进程的状态转换为阻塞态。

7. 在父进程中发送终止信号给子进程，观察子进程的终止情况。

实验结果与分析：经过实验，我们成功地创建了子进程并在子进程中执行了一段代码。

父进程能够正确地等待子进程的终止并获取子进程的退出状态码。

在子进程中使用sleep()系统调用后，观察到子进程的状态转换为阻塞态。

当父进程发送终止信号给子进程时，子进程能够正确地终止执行。

进程控制实验报告1．目的和要求通过本实验掌握Linux操作系统的进程创建fork（），进程终止exit（），等待进程终止wait（），执行用户可执行程序exec（）等进程控制的操作，利用Linux操作系统提供的进程通信的工具实现进程间的同步。

2．实验内容问题：求100000个浮点数（精确小数点右4位）的平均值（和、最大值、最小值）流程图：步骤：1、随机生成100000个浮点数（父进程）；2、创建4个子进程，分别求25000个浮点数之和；3、父进程完成100000个浮点数之和并打印结果。

4、统计顺序计算的时间和多个进程采用多道程序设计完成计算的时间。

3．参考文献Keith Haviland等著/《UNIX 系统编程》/第二版/电子工业出版社/03年1月出版4．实验内容1、求解问题的顺序程序及运行时间#include<stdio.h>#include<sys/time.h>#include<stdlib.h>#include<unistd.h>int main(void){int i, j;double array[4][25000]double allsum=0.0;time_t start, end;struct timeval js;for (i = 0; i < 4; i++)for (j = 0; j < 25000; j++)array[i][j]=(double)rand() / (double)RAND_MAX;gettimeofday(&js, NULL) ;start = _usec;for (i = 0; i < 4; i++){for (j = 0; j < 25000; j++)sum[i] += array[i][j];}for ( i=0; , i< 4; i++){allsum= sum[i] ;printf("sum = %f\n", allsum);}gettimeofday(&tv, NULL) ;end = _usec;printf("time = %d\n", end – start);return 0;}运行结果为：sum=49951.056669time=14562、求解问题的多道程序设计的程序及运行时间#include <sys/types.h>#include <sys/time.h>#include <unistd.h>#include <stdio.h>#include <stdlib.h>double array[4][25000];double sum[4] = {0.0}double allsum[4];double sum = 0.0;int fpipe[4][2];int main(void){int i, j;struct timeval tv;time_t start, end;for (i = 0; i < 4; i++)for (j = 0; j < 25000; j++)a[i][j]=(double)rand() / (double)RAND_MAX gettimeofday(&tv, NULL);start = _usec;for (i = 0; i < 4; i++){if (pipe(fpipe[i]) < 0){printf("pipe error!\n");exit(1);}if (fork() == 0) {for (j = 0; j < 25000; ++j){sum1[i] += a[i][j];}write(fpipe[i][1], &sum1[i],sizeof(double));exit(0);}else{if ( !read(fpipe[i][0], &sum[i], sizeof(double))){exit(1);}printf("sum[%d] = %f\n", i, sum[i]);}}for (i = 0; i< 4; i++)sum += sum[i];printf("sum= %f\n", sum);gettimeofday(&tv, NULL);end = _usec;printf("time= %d\n", end - start);return 0;}其结果为：Sum=49551.056669Time=5035其部分生成的数字为：………..0.5800 0.0670 0.4490 0.5106 0.6561 0.7088 0.5746 0.7144 0.4324 0.2044 0.0959 0.4480 0.0764 0.3211 0.0312 0.1233 0.3066 0.3779 0.0558 0.5903 0.2981 0.3085 0.6777 0.9622 0.4080 0.2521 0.0996 0.4301 0.5412 0.2261 0.0797 0.1212 0.2931 0.5287 0.6318 0.9492 0.2376 0.2065 0.6636 0.6700 0.4109 0.7596 0.1180 0.4873 0.0807 0.1492 0.6106 0.3873 0.5271 0.6664 0.9776 0.8252 0.9749 0.6553 0.7874 0.3829 0.9075 0.8870 0.8130 0.4486 0.1131 0.8927 0.5698 0.4062 0.4214 0.2017 0.3554 0.6590 0.4081 0.0190 0.3290 0.8190 0.7786 0.4470 0.3063 0.8593 0.5962 0.9169 0.2466 0.1233 0.5833 0.2242 0.9485 0.5582 0.8796 0.7359 0.9411 0.7870 0.6229 0.7541 0.2357 0.7360 0.6468 0.8055 0.1422 0.0683 0.0072 0.4976 0.7273 0.4153 0.5166 0.0563 0.2343 0.2952 0.5033 0.5407 0.1544 0.0995 0.4576 0.4010 0.2227 0.0409 0.6253 0.1712 0.5991 0.5049 0.9071 0.5402 0.2919 0.5300 0.2943 0.5275 0.2660 0.9411 0.3330 0.4082 0.0094 0.3402 0.9058 0.7367 0.7555 0.4224 0.7929 0.9898 0.7175 0.2962 0.5305 0.8719 0.3957 0.9881 0.2730 0.6184 0.0289 0.8983 0.7896 0.6280 0.4031 0.6968 0.1682 0.6950 0.2268 0.4625 0.2225 0.4928 0.4036 0.5555 0.9010 0.4130 0.8957 0.8068 0.1496 0.6512 0.2292 0.9426 0.6411 0.9467 0.2388 0.1716 0.8186 0.6345 0.1597 0.0916 0.2529 0.1886 0.9899 0.0425 0.8166 0.3930 0.7393 0.9848 0.0881 0.9661 0.4473 0.3106 0.4589 0.8508 0.8661 0.3599 0.2638 0.7619 0.1668 0.4134 0.4131 0.3959 0.3560 0.0541 0.3426 0.5948 0.2257 0.1613 0.2293 0.3854 0.2529 0.4822 0.5740 0.2428 0.5247 0.3907 0.6359 0.2639 0.3755 0.7239 0.2300 0.8227 0.0345 0.6889 0.6736 0.9006 0.0488 0.9374 0.6625 0.2156 0.3508 0.0755 0.6115 0.7068 0.1297 0.9541 0.3017 0.3554 0.1154 0.5309 0.7408 0.3683 0.0131 0.3148 0.6111 0.5378 0.7055 0.2470 0.8017 0.0810 0.9709 0.0317 0.9037 0.0053 0.7206 0.5773 0.9060 0.7694 0.5147 0.5684 0.9850 0.8655 0.6440 0.5966 0.5724 0.7736 0.5507 0.8740 0.1291 0.6661 0.4050 0.8699 0.0344 0.4181 0.1847 0.6455 0.9558 0.8902 0.8924 0.7575 0.9712 0.8633 0.7892 0.8749 0.8686 0.5098 0.4523 0.7746 0.2792 0.9670 0.3430 0.2643 0.8325 0.9870 0.8608 0.4048 0.7606 0.4115 0.2789 0.8897 0.0776 0.6838 0.7595 0.1120 0.1019 0.9443 0.7575 0.0577 0.8345 0.6499 0.8152 0.8057 0.5132 0.6044 0.6806 0.3818 0.1142 0.1329 0.1564 0.3935 0.0998 0.4995 0.6578 0.9323 0.4864 0.5186 0.3372 0.2471 0.9301 0.6160 0.1367 0.0077 0.2999 0.8963 0.1197 0.4018 0.8406 0.8772 0.4595 0.6750 0.5271 0.2747 0.4807 0.0403 0.8791 0.1614 0.4222 0.99330.2942 0.5786 0.3868 0.3941 0.0781 0.0446 0.3264 0.5645 0.5632 0.6635 0.8116 0.4933 0.2796 0.9484 0.5010 0.5794 0.8446 0.6207 0.9812 0.6852 0.4979 0.4407 0.3602 0.0251 0.7154 0.8410 0.0654 0.5945 0.0023 0.4876 0.5878 0.2966 0.0662 0.9746 0.6906 0.1443 0.0192 0.0170 0.7089 0.5824 0.6806 0.5205 0.0756 0.9602 0.4688 0.5766 0.5396 0.3135 0.1974 0.5208 0.9987 0.6953 0.9615 0.3589 0.7204 0.6769 0.1999 0.7858 0.2713 0.2022 0.2734 0.8591 0.4988 0.3396 0.8338 0.1894 0.4840 0.8530 0.2064 0.1928 0.4353 0.8870 0.7133 0.5110 0.8472 0.1821 0.0876 0.3868 0.4956 0.2850 0.9076 0.4942 0.9803 0.8691 0.8531 0.7007 0.5459 0.0530 0.4865 0.8172 0.2552 0.7599 0.6764 0.7540 0.0996 0.5101 0.9434 0.5835 0.3631 0.1499 0.7763 0.7984 0.0369 0.4896 0.3094 0.8840 0.6717 0.3970 0.2708 0.1673 0.6819 0.1784 0.6615 0.6622 0.0474 0.5146 0.3629 0.5933 0.5677 0.8494 0.4106 0.8229 0.6093 0.0869 0.5769 0.7089 0.5971 0.5204 0.2924 0.9602 0.6703 0.0687 0.7586 0.7071 0.5583 0.0680 0.5912 0.2300 0.4649 0.8620 0.3973 0.1469 0.0404 0.0588 0.8091 0.0878 0.5735 0.1721 0.6811 0.1411 0.0215 0.0917 0.9641 0.6308 0.1786 0.5410 0.3397 0.7757 0.0614 0.6322 0.7358 0.7317 0.7009 0.4944 0.4388 0.2592 0.5624 0.0300 0.4893 0.0273 0.8920 0.8866 0.1742 0.9323 0.9454 0.9834 0.0201 0.5189 0.1554 0.7012 0.6600 0.1769 0.7929 0.6241 0.8077 0.9715 0.1651 0.1475 0.7472 0.2265 0.7796 0.4830 0.9581 0.4805 0.9774 0.3969 0.7398 0.5398 0.4269 0.2291 0.5671 0.3189 0.1157 0.7414 0.2512 0.0611 0.7247 0.2713 0.5800 0.8801 0.9725 0.2400 0.0570 0.7654 0.8640 0.8648 0.7369 0.0291 0.0123 0.4841 0.2555 0.7919 0.9671 0.2136 0.2724 0.9445 0.6105 0.0122 0.4844 0.0374 0.2413 0.0515 0.3563 0.3569 0.7929 0.6074 0.4180 0.5176 0.8787 0.9980 0.3977 0.8513 0.2379 0.4548 0.6167 0.1020 0.3195 0.3536 0.1310 0.3318 0.8377 0.3866 0.1237 0.8049 0.6002 0.3961 0.7494 0.2107 0.4083 0.2338 0.2481 0.6496 0.2852 0.6044 0.0065 0.0781 0.2118 0.4245 0.5957 0.0906 0.4225 0.9934 0.9418 0.6605 0.4482 0.5585 0.7624 0.7677 0.9122 0.8934 0.0995 0.7499 0.2800 0.2231 0.5548 0.8802 0.6192 0.3042 0.0909 0.0275 0.5379 0.3391 0.6771 0.8232 0.9435 0.6836 0.9013 0.1553 0.1082 0.4970 0.2459 0.5307 0.4904 0.1877 0.1911 0.9385 0.7462 0.9536 0.7062 0.6584 0.8470 0.8057 0.4083 0.1270 0.0288 0.9631 0.0072 0.6480 0.2672 0.0982 0.6756 0.8051 0.4372 0.3526 0.6283 0.3807 0.0363 0.5296 0.5360 0.1444 0.0265 0.7818 0.6751 0.5169 0.9695 0.8662 0.4554 0.7157 0.8198 0.1617 0.3741 0.6668 0.9674 0.7824 0.7938 0.9962 0.7455 0.8010 0.6442 0.0127 0.8992 0.3198 0.8178 0.3364 0.6724 0.4461 0.7171 0.7087 0.9757 0.2531 0.8531 0.0022 0.0349 0.5282 0.5191 0.0044 0.3944 0.9746 0.7202 0.2142 0.1362 0.0943 0.8810 0.1036 0.8767 0.6748 0.0998 0.6222 0.4758 0.7441 0.6349 0.3750 0.0639 0.4527 0.7114 0.7363 0.8989 0.4285 0.4450 0.8746 0.6816 0.2981 0.8768 0.7165 0.8263 0.3959 0.7209 0.2207 0.3705 0.4411 0.4349 0.5068 0.5353 0.3159 0.6104 0.4121 0.9907 0.7102 0.0343 0.4665 0.4543 0.6692 0.8415 0.5181 0.1219 0.5530 0.2544 0.0208 0.9815 0.6994 0.8954 0.6631 0.9976 0.7722 0.3796 0.8239 0.1681 0.1005 0.0446 0.5387 0.5415 0.4795 0.0454 0.0769 0.7955 0.6558 0.4890 0.7862 0.3660 0.52320.2527 0.8203 0.1924 0.0942 0.3384 0.3143 0.6472 0.5928 0.3351 0.6287 0.2923 0.2305 0.2918 0.2898 0.0027 0.6714 0.1137 0.1708 0.7719 0.1583 0.7095 0.3134 0.6378 0.7549 0.3903 0.4333 0.4108 0.8793 0.2195 0.7768 0.4025 0.4722 0.5971 0.5949 0.5664 0.9355 0.9092 0.2136 0.5283 0.2443 0.8423 0.8206 0.4748 0.1342 0.1105 0.4775 0.8056 0.2242 0.6483 0.5774 0.3825 0.3578 0.8909 0.0203 0.1127 0.2812 0.4536 0.5235 0.1605 0.6731 0.3003 0.5630 0.1453 0.8974 0.1579 0.7117 0.8329 0.0670 0.9253 0.3612 0.3113 0.7676 0.1818 0.7861 0.9018 0.2923 0.2635 0.7073 0.5165 0.9118 0.2848 0.8989 0.2696 0.1757 0.9193 0.3824 0.4569 0.3729 0.9059 0.6173 0.0460 0.2062 0.1803 0.1912 0.1036 0.3382 0.9029 0.9364 0.4052 0.8282 0.2976 0.7165 0.5958 0.4795 0.5026 0.4976 0.7718 0.7661 0.2049 0.2882 0.6780 0.4897 0.1871 0.9476 0.6654 0.1064 0.3300 0.1222 0.4793 0.2359 0.7396 0.5253 0.4420 0.9199 0.7165 0.5456 0.2581 0.6194 0.4820 0.6633 0.4476 0.7797 0.3798 0.0435 0.2591 0.8824 0.5411 0.0309 0.6485 0.7460 0.3191 0.3265 0.2357 0.5062 0.2741 0.9011 0.6126 0.6041 0.0233 0.0919 0.8399 0.7629 0.6172 0.2819 0.6828 0.3337 0.8275 0.9408 0.9531 0.3095 0.6041 0.4007 0.0892 0.9839 0.4442 0.3483 0.8663 0.9852 0.3792 0.5148 0.7312 0.6983 0.8413 0.9669 0.2045 0.1154 0.8680 0.8171 0.7195 0.8913 0.9090 0.5594 0.6542 0.5262 0.8414 0.3369 0.8599 0.6689 0.2778 0.8129 0.9784 0.8819 0.2137 0.0676 0.8658 0.6578 0.4160 0.7321 0.6430 0.7952 0.2470 0.3743 0.4935 0.0883 0.3412 0.6980 0.2037 0.2092 0.5152 0.9232 0.1005 0.4242 0.4827 0.7546 0.9504 0.3240 0.0916 0.8102 0.9929 0.3693 0.6232 0.9713 0.2512 0.8369 0.0390 0.1170 0.4947 0.4549 0.8492 0.1377 0.2501 0.0961 0.5120 0.7436 0.1844 0.8532 0.4416 0.3882 0.0623 0.9568 0.3114 0.1628 0.3810 0.7941 0.9174 0.3314 0.1181 0.0090 0.1416 0.1110 0.3783 0.7648 0.0824 0.6295 0.6017 0.1213 0.7466 0.0964 0.5763 0.5957 0.2341 0.8264 0.6919 0.7461 0.5700 0.8763 0.5992 0.0117 0.2645 0.6616 0.9685 0.5759 0.8244 0.3495 0.3700 0.7417 0.6809 0.4881 0.7507 0.8225 0.5992 0.1290 0.5873 0.6815 0.7585 0.1890 0.8029 0.5051 0.2853 0.3792 0.1008 0.5194 0.2056 0.7926 0.2655 0.7756 0.6689 0.8648 0.7873 0.9334 0.5263 0.7558 0.5093 0.3507 0.1053 0.8794 0.0924 0.7861 0.3675 0.8431 0.6086 0.9667 0.9721 0.1960 0.6482 0.7306 0.3850 0.4511 0.2357 0.6703 0.8303 0.3365 0.1897 0.0358 0.1292 0.4552 0.8115 0.7981 0.3200 0.5988 0.7315 0.8463 0.3546 0.2409 0.1970 0.4598 0.1202 0.2894 0.2460 0.4877 0.1326 0.8546 0.4544 0.1047 0.0506 0.1026 0.8353 0.4355 0.5537 0.0711 0.1058 0.3840 0.4076 0.2956 0.4198 0.5368 0.7508 0.2313 0.3349 0.0708 0.8300 0.0664 0.9171 0.1846 0.3073 0.1141 0.6444 0.4275 0.4036 0.8904 0.9152 0.5362 0.7450 0.3696 0.6408 0.7956 0.4723 0.4762 0.2311 0.0259 0.5473 0.3370 0.4099 0.9548 0.6325 0.8297 0.4916 0.3833 0.0610 0.8265 0.4542 0.8910 0.8929 0.3713 0.0756 0.2002 0.4854 0.7200 0.6277 0.8890 0.6104 0.5430 0.4252 0.3554 0.9126 0.0660 0.1510 0.3849 0.5422 0.3821 0.4108 0.0895 0.7191 0.8207 0.0443 0.3516 0.6504 0.5359 0.7349 0.7114 0.3624 0.1891 0.6024 0.2553 0.5604 0.6779 0.4555 0.0458 0.3979 0.0832 0.9348 0.0083 0.6262 0.3600 0.3636 0.5388 0.4261 0.5146 0.9236 0.96830.8967 0.3345 0.0577 0.6158 0.1552 0.1021 0.9673 0.8056 0.6380 0.7023 0.5170 0.0004 0.8913 0.1193 0.2557 0.4517 0.7972 0.7112 0.4975 0.1951 0.7944 0.4324 0.2034 0.4206 0.7924 0.5670 0.9594 0.2184 0.0817 0.8831 0.1867 0.9784 0.2175 0.2444 0.5941 0.3727 0.3465 0.5614 0.1783 0.9845 0.2637 0.6952 0.9849 0.1550 0.8145 0.2406 0.6067 0.6118 0.9518 0.1042 0.8069 0.7463 0.5366 0.0103 0.1669 0.3290 0.5773 0.1263 0.5474 0.6590 0.0094 0.7341 0.6374 0.2269 0.9786 0.2315 0.5996 0.3250 0.7929 0.7779 0.3095 0.0566 0.4731 0.2944 0.2116 0.2877 0.5350 0.8184 0.8994 0.4868 0.9226 0.7063 0.2331 0.4592 0.7166 0.3999 0.7881 0.2940 0.5263 0.3356 0.9530 0.5356 0.0697 0.5903 0.7625 0.0482 0.8218 0.3621 0.3733 0.6147 0.1400 0.6828 0.6713 0.6131 0.9772 0.8830 0.9008 0.5122 0.7013 0.8002 0.9990 0.6239 0.5065 0.2320 0.0831 0.2231 0.6320 0.8713 0.5171 0.1582 0.2068 0.4700 0.6939 0.2765 0.0604 0.4564 0.3247 0.8821 0.8185 0.6979 0.4969 0.9585 0.3807 0.1682 0.5717 0.3579 0.0511 0.4724 0.8701 0.7525 0.2726 0.8691 0.3764 0.7792 0.1011 0.4595 0.0023 0.7331 0.3308 0.5194 0.8913 0.5376 0.9894 0.5852 0.8140 0.0498 0.0416 0.1387 0.9320 0.8601 0.8367 0.4288 0.8186 0.2174 0.5970 0.3903 0.5753 0.6481 0.8627 0.4454 0.4006 0.1354 0.3144 0.7770 0.9146 0.4155 0.2365 0.9169 0.1486 0.5673 0.4363 0.0399 0.1048 0.4257 0.6251 0.9189 0.47555．心得体会本以为多道程序设计出来的代码在运行时间上比顺序的要短，但是实际上由于现在的PC机都是单CPU和CPU单核的比较多，包括我自己的。