进程控制实验
进程控制实验报告
一、实验目的本次实验旨在通过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, ¶m) == -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.信号的机理：信号是用来通知进程某个特定的事件已经发生。
信号是由特定的事件产生，信号必须要发送到进程，一旦发送，进程必须得到处理。
信号可以可以有系统默认处理也可以用户自定义处理。
操作系统实验3-进程控制
WORD wMajorReq=(WORD)(dwVerReq>16);
WORD wMinorReq=(WORD)(dwVerReq&0xffff);
::cout<<"Process ID:"<<dwIdThis<<",requires OS:"<<wMajorReq<<wMinorReq<<::endl;
{
//改变优先级
::SetPriorityClass(
::GetCurrentProcess(), //利用这一进程
HIGH_PRIORITY_CLASS); //改变为high
//报告给用户
::cout<<"Task Manager should indicate this "
"process is high priority."<<::endl;
//设置版本信息的数据结构，以便保存操作系统的版本信息
OSVERSIONINFOEX osvix;
::ZeroMemory(&osvix,sizeof(osvix));
osvix.dwOSVersionInfoSize=sizeof(osvix);
//提取版本信息和报告
::GetVersionEx(reinterpret_cast<LPOSVERSIONINFO>(&osvix));
Parent();
}
return 0;
}
分析：程序4-3.cpp说明了一个进程从“生”到“死”的整个一生，第一次执行时，它创建一个子进程，其行为如同“父亲”。在创建子进程之前，先创建一个互斥的内核对象，其行为对于子进程来说，如同一个“自杀弹”。当创建子进程时，就打开了互斥体并在其他线程中进行别的处理工作，同时等待着父进程使用ReleaseMutex（）API发出“死亡”信号。然后用Sleep（）API调用来模拟父进程处理其他工作，等完成时，指令子进程终止。
进程控制实验报告
测试过程: （实验中出现的问题、错误、解决方法）创建好项目和文件, 对文件进行编译和运行, 编译没有错误, 但是运行总是提示有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在整个系统中都可使用。
操作系统进程控制实验报告
操作系统进程控制实验报告一、实验目的操作系统进程控制是操作系统中的重要概念和核心功能之一。
本次实验的目的在于深入理解操作系统中进程的概念、状态及其转换，掌握进程创建、终止、阻塞和唤醒等操作的实现原理和方法，通过实际编程和调试，观察进程的行为和特性，从而提高对操作系统原理的理解和应用能力。
二、实验环境本次实验使用的操作系统为 Windows 10，编程语言为 C+＋，开发工具为 Visual Studio 2019。
三、实验原理（一）进程的概念进程是操作系统中进行资源分配和调度的基本单位，它包含了程序代码、数据、堆栈等资源。
进程具有独立性、动态性和并发性等特点。
（二）进程的状态进程的状态通常包括就绪态、运行态和阻塞态。
就绪态表示进程已具备运行条件，等待被调度；运行态表示进程正在 CPU 上执行；阻塞态表示进程因等待某个事件而暂停执行。
（三）进程控制的基本操作1、进程创建：通过系统调用创建新的进程，为其分配资源并初始化。
2、进程终止：当进程完成任务或出现异常时，结束其执行并回收资源。
3、进程阻塞：进程在等待某个事件时，主动进入阻塞态。
4、进程唤醒：当等待的事件发生时，将阻塞的进程唤醒，使其进入就绪态。
四、实验内容与步骤（一）进程创建1、编写 C+＋程序，使用系统提供的函数创建新的进程。
2、在新进程中执行特定的任务，例如打印输出信息。
｀｀｀cppinclude ＜windowsh>include ＜iostream>int main(）｛STARTUPINFO si;PROCESS_INFORMATION pi;ZeroMemory(＆si, sizeof(si)）；sicb ＝ sizeof(si)；ZeroMemory(＆pi, sizeof(pi)）；／／创建新进程if （！CreateProcess(NULL, ／／应用程序名称＂C:＼＼Path\＼To\＼Your\＼ChildProcessexe"，／／命令行参数NULL, NULL, FALSE, 0, NULL, NULL, ＆si, ＆pi)）｛std:：cerr ＜＜＂CreateProcess failed Error code: ＂＜＜GetLastError(）＜＜ std:：endl;return 1;｝／／等待子进程结束WaitForSingleObject(pihProcess, INFINITE)；／／关闭进程和线程句柄CloseHandle(pihProcess)；CloseHandle(pihThread)；return 0;｝｀｀｀（二）进程终止1、在创建的进程中设置条件，当满足条件时主动终止进程。
进程控制实验报告
进程控制实验报告进程控制实验报告引言：进程控制是操作系统中的重要概念之一，它负责管理和调度计算机系统中的各个进程，确保它们能够按照一定的顺序和优先级进行执行。
本实验旨在通过编写一个简单的进程控制程序，加深对进程控制的理解，并探索其在实际应用中的作用。
实验目的：1. 理解进程控制的基本概念和原理；2. 掌握进程创建、终止和切换的方法；3. 熟悉进程调度算法的实现；4. 分析进程控制在实际应用中的意义和效果。
实验过程：本次实验中，我们选择使用C语言编写一个简单的进程控制程序，通过创建多个进程并进行调度，观察它们的执行顺序和状态变化。
首先，我们定义了一个进程结构体，包含进程ID、进程状态和进程优先级等信息。
然后，我们编写了创建进程的函数，通过调用系统调用接口fork()来创建新的进程，并为其分配唯一的进程ID。
在进程创建完成后，我们实现了一个简单的进程调度算法，根据进程的优先级和状态来决定下一个要执行的进程。
我们使用了优先级队列来管理进程，将优先级高的进程排在队列的前面，以确保它们能够优先执行。
接下来，我们模拟了进程的运行过程，通过设置进程的状态和优先级，来模拟进程的创建、终止和切换。
我们观察到，当一个进程被创建时，它会被添加到就绪队列中，等待系统调度执行。
当一个进程的时间片用完或者发生阻塞时，它会被暂停并切换到下一个就绪进程执行。
实验结果：通过多次运行实验程序，我们观察到进程的创建、终止和切换过程。
我们发现，进程的创建是一个相对较慢的过程，而进程的切换则非常迅速。
这是因为进程的创建需要为其分配资源和初始化环境，而进程的切换只需要保存和恢复进程的状态即可。
我们还发现，进程的优先级对于进程的执行顺序有重要影响。
当一个进程的优先级较高时，它会被优先执行，而其他进程则需要等待。
这使得系统能够根据进程的重要性和紧急程度来进行合理的调度，提高系统的效率和响应速度。
讨论与总结：进程控制是操作系统中非常重要的一部分，它负责管理和调度计算机系统中的各个进程。
实验一 进程控制实验
实验一进程控制实验实验目的1、掌握进程的概念，了解进程的结构、状态，认识进程并发执行的实质。
2、熟悉进程控制相关的命令。
3、能够使用系统调用完成进程的创建，形成多进程并发执行的环境.4、了解进程控制的系统调用，可实现对进程的有效控制实验基础一、LINUX进程引入进程概念，是为了描述多道程序的并发执行。
为了执行一个程序，首先要创建进程。
资源足够时，os为进程分配内存资源。
操作系统利用PCB来控制和管理进程，其中为每个进程赋予惟一的进程标识符就放在PCB中。
Linux操作系统本身的运行，就是由一系列服务进程和系统监控进程等组成的，在Linux 上运行的任何东西，包括每一个用户的工作也都是以进程的形式运行的。
与传统的进程一致，Linux进程也主要有3部分组成：程序段、数据段和进程控制块。
程序段存放进程执行的指令代码，具有可读、可执行、不可修改属性，但允许系统中多个进程共享这一代码段，因此程序与进程具有一对多的属性。
数据段是进程执行时直接操作的所有数据（包括变量在内），具有可读、可写、不可执行属性。
Linux中每个进程PCB的具体实现用一个名为task_struct的数据结构来表示，在Linux 内核中有个默认大小为512B的全局数组task，该数组的元素为指向task_struct结构的指针。
在创建新进程时，Linux将会在系统空间中分配一个task_struct结构，并将其首地址加入到task数组。
当前正在运行的进程的task_struct结构由一个current指针来指示。
Linux 2.4.20内核版本中的task_struct结构在include/linux/sched.h中定义。
其中的state成员描述了进程的当前状态，系统中的每个进程都将处于以下五种状态之一：（1）TASK_RUNNING：可运行态，表示进程正在运行，或准备运行（就绪）。
（2）TASK_INTERRUPUTIBLE：可中断等待态，表示进程在等待队列中等待某些条件的达成，一旦条件满足就被唤醒，也能够由其他进程通过信号或中断唤醒。
进程控制与进程通信程序实验报告
进程控制与进程通信程序实验报告一、引言进程是计算机系统中最基本的概念之一，是操作系统中最小的资源管理单位。
进程控制与进程通信是操作系统中重要的内容，涉及到进程的创建、调度和终止，以及进程间的信息传递和同步管理。
本实验旨在通过编写进程控制与进程通信程序，加深对操作系统中进程管理和通信机制的理解。
二、实验目的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操作，实现进程间的同步和互斥。
五、实验结果通过实验，我们成功实现了进程的创建、调度和终止，以及进程间的信息传递和同步管理。
操作系统实验-进程控制
实验一、进程控制实验1.1 实验目的加深对于进程并发执行概念的理解。
实践并发进程的创建和控制方法。
观察和体验进程的动态特性。
进一步理解进程生命期期间创建、变换、撤销状态变换的过程。
掌握进程控制的方法，了解父子进程间的控制和协作关系。
练习 Linux 系统中进程创建与控制有关的系统调用的编程和调试技术。
1.2 实验说明1）与进程创建、执行有关的系统调用说明 进程可以通过系统调用fork()创建子进程并和其子进程并发执行.子进程初始的执行映像是父进程的一个复本.子进程可以通过 exec()系统调用族装入一个新的执行程序。
父进程可以使用 wait()或 waitpid()系统调用等待子进程的结束并负责收集和清理子进程的退出状态。
fork()系统调用语法:pid_t#include <unistd.h>fork(void);fork 成功创建子进程后将返回子进程的进程号,不成功会返回-1.exec 系统调用有一组 6 个函数,其中示例实验中引用了 execve 系统调用语法:#include <unistd.h>const char * envp[]);path 要装const char *argv[],int execve(const char *path,入的新的执行文件的绝对路径名字符串.argv[] 要传递给新执行程序的完整的命令参数列表(可以为空).envp[] 要传递给新执行程序的完整的环境变量参数列表(可以为空).Exec 执行成功后将用一个新的程序代替原进程，但进程号不变，它绝不会再返回到调用进程了。
如果 exec 调用失败，它会返回-1。
wait() 系统调用语法:#include <sys/types.h>pid_t#include <sys/wait.h>wait(int *status);status 用pid_t waitpid(pid_t pid,int *status,int option);于保留子进程的退出状态pid 可以为以下可能值：-1 等待所有 PGID 等于 PID 的绝对值的子进程1 等待所有子进程0 等待所有 PGID 等于调用进程的子进程>0 等待 PID 等于 pid 的子进程 option 规定了调用 waitpid 进程的行为：WNOHANG 没有子进程时立即返回WUNTRACED 没有报告状态的进程时返回wait 和 waitpid 执行成功将返回终止的子进程的进程号，不成功返回-1。
实验三 进程管理-进程的控制实验
（1）首先查找调用进程是否有子进程，若无，则返回出错码；（2）若找到一处于“僵死状态”的子进程，则将子进程的执行时间加到父进程的执行时间上，并释放子进程的进程表项；（3）若未找到处于“僵死状态”的子进程，则调用进程便在可被中断的优先级上睡眠，等待其子进程发来软中断信号时被唤醒。
4、exit（）终止进程的执行。
系统调用格式：void exit(status)int status;其中，status 是返回给父进程的一个整数，以备查考。
为了及时回收进程所占用的资源并减少父进程的干预，LINUX/LINUX 利用exit( )来实现进程的自我终止，通常父进程在创建子进程时，应在进程的末尾安排一条exit( )，使子进程自我终止。
exit(0)表示进程正常终止，exit(1)表示进程运行有错，异常终止。
如果调用进程在执行exit( )时，其父进程正在等待它的终止，则父进程可立即得到其返回的整数。
核心须为exit( )完成以下操作：（1）关闭软中断（2）回收资源（3）写记帐信息（4）置进程为“僵死状态”参考程序#include<stdio.h>#include<unistd.h>main( ){in t pid;pid=fork( ); /*创建子进程*/switch(pid){case -1:printf("fork fail!\n");exit(1);case 0: /*创建失败*//*子进程*/execl("/bin/ls","ls","1","color",NULL); printf("exec fail!\n");exit(1);default:wait(NULL);/*父进程*/ /*同步*/printf("ls completed !\n");exit(0);}}运行结果执行命令ls -l -color ，（按倒序）列出当前目录下所有文件和子目录；ls completed!分析原因程序在调用fork( )建立一个子进程后，马上调用wait( )，使父进程在子进程结束之前，一直处于睡眠状态。
实验一进程控制描述与控制
实验一进程控制描述与控制公司内部档案编码：[OPPTR-OPPT28-OPPTL98-OPPNN08]实验一：进程控制描述与控制[1] Windows“任务管理器”的进程管理一、实验名称Windows“任务管理器”的进程管理二、实验目的通过在Windows 任务管理器中对程序进程进行响应的管理操作，熟悉操作系统进程管理的概念，学习观察操作系统运行的动态性能。
三、实验内容与步骤1. 使用任务管理器终止进程2. 显示其他进程计数器3. 更改正在运行的程序的优先级?启动并进入Windows环境，单击Ctrl + Alt + Del键，或者右键单击任务栏，在快捷菜单中单击“任务管理器”命令，打开“任务管理器”窗口。
在本次实验中，你使用的操作系统版本是：_______Windows_XP______________________当前机器中由你打开，正在运行的应用程序有：1) _______ ________2) ___________实验一___3) _________操作系统_____________4) ___________百度首页 ________5)Windows“任务管理器”的窗口由____4__个选项卡组成，分别是：1) _______应用程序______________2) _进程__________________3) ______ 性能___________________4) ________联网__________________当前“进程”选项卡显示的栏目分别是 (可移动窗口下方的游标/箭头，或使窗口最大化进行观察) ：1. 使用任务管理器终止进程步骤1：单击“进程”选项卡，一共显示了__40___个进程。
请试着区分一下，其中：系统 (SYSTEM) 进程有____25__个，填入表3-1中。
?表3-1 实验记录?Wmiprvse SYSTEM005376kcidaemon SYSTEM00300kcidaemon SYSTEM00856kcidaemon SYSTEM50284kcisvc SYSTEM00924kcsrss SYSTEM007412kmqtgsvc SYSTEM?004144kmqsvc SYSTEM006632ksnmp SYSTEM004340ktcpservcs SYSTEM003840k服务 (SERVICE) 进程有_____5_个，填入表3-2中。
计算机操作系统实验-进程的控制
实验二：进程的控制1 ．实验目的通过进程的创建、撤消和运行加深对进程概念和进程并发执行的理解，明确进程与程序之间的区别。
进程概念和程序概念最大的不同之处在于：(1)进程是动态的，而程序是静态的。
(2)进程有一定的生命期，而程序是指令的集合，本身无“运动”的含义。
没有建立进程的程序不能作为1个独立单位得到操作系统的认可。
(3)1个程序可以对应多个进程，但1个进程只能对应1个程序。
进程和程序的关系犹如演出和剧本的关系。
(4)进程和程序的组成不同。
从静态角度看，进程由程序、数据和进程控制块（PCB）三部分组成。
而程序是一组有序的指令集合。
2 ．实验内容(1) 了解系统调用fork()、execvp()和wait()的功能和实现过程。
(2) 编写一段程序，使用系统调用fork()来创建两个子进程，并由父进程重复显示字符串“parent:”和自己的标识数，而子进程则重复显示字符串“child:”和自己的标识数。
(3) 编写一段程序，使用系统调用fork()来创建一个子进程。
子进程通过系统调用execvp()更换自己的执行代码，新的代码显示“new program.”。
而父进程则调用wait()等待子进程结束，并在子进程结束后显示子进程的标识符，然后正常结束。
3 ．实验步骤（1）gedit创建进程1.c（2）使用gcc 1.c -o 1编译并./1运行程序1.c#include<stdio.h>#include<sys/types.h>#include<unistd.h>#include<sys/wait.h>void main(){int id;if (fork()==0){printf("child id is %d\n",getpid());}else if (fork()==0){printf("child2 id is %d\n",getpid());}else{id=wait(NULL);printf("parent id is %d\n",getpid());}}（3）运行并查看结果（4）gedit创建进程2.c使用gcc 2.c -o 2编译并./2运行程序2.c1 #include<stdio.h>2 #include<stdlib.h>3 #include<sys/types.h>4 #include<unistd.h>5 #include<sys/wait.h>6 int main()7 {8 pid_t pid;9 char *a[]={"ls","-l","/etc/passwd",0};10 int result;11 pid=fork();12 if(pid<0)13 {printf("fork error!");}14 else if(pid==0)15 {16 printf("new program!\n");17 execvp("ls",a);18 exit(0);19 }20 else21 {22 int e=waitpid(pid,&result,0);23 printf("child peocess PID:%d\n",e);24 exit(0);25 }26 }（5）运行并查看结果4 ．思考（1）系统调用fork()是如何创建进程的？1）申请空白PCB 2）为新进程分配资源3）初始化进程控制块（初始化标识信息，初始化处理机状态信息，初始化处理机控制信息，）4）将新进程插入就绪队列(2)当首次将CPU 调度给子进程时，其入口在哪里？进程的进程控制块（PCB）结构中有指向其TTS（任务状态段）的指针，TTS里面存放着进程的入口。
操作系统原理实验4-进程控制
《操作系统原理》实验报告
实验序号：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、认识和了解并发执行的实质。
二.实验环境操作系统：Redhat9.0 编辑器：vim 编译器：gcc三．实验要求：1．编写一C语言程序，实现在程序运行时通过系统调用fork( )创建两个子进程，使父、子三进程并发执行，父亲进程执行时屏幕显示“I am father”，儿子进程执行时屏幕显示“I am son”，女儿进程执行时屏幕显示“I am daughter”。
2．多次连续反复运行这个程序，观察屏幕显示结果的顺序，直至出现不一样的情况为止。
记下这种情况，试简单分析其原因。
3．修改程序，利用nice ( ) 改变各进程的优先级，观察不同情况下进程调度效果的区别。
4．修改程序，在父、子进程中分别使用wait、exit等系统调用“实现”其同步推进，多次反复运行改进后的程序，观察并记录运行结果。
四．实验步骤:1.编写代码；2.运行程序3.利用ps 口令查看进程，验证试验结果五．实验代码://fork.c#include <sys/types.h>#include <unistd.h>#include <stdio.h>#include <stdlib.h>int main(){pid_t pid;char *message;int n;printf("fork program starting\n");pid = fork();if (pid == -1){perror("fork failed");exit(1);}else if (pid == 0){message = "I am son";n = 2;}else{message = "I am father";n = 1;pid = fork();if (pid == -1){perror("fork failed");exit(1);}else if (pid == 0){message = "I am daughter";n = 3;}}for (;n>0;n--){puts(message);sleep(1);}exit(0);}//nice.c#include <sys/types.h>#include <unistd.h>#include <stdio.h>#include <stdlib.h>int main(){pid_t pid;char *message;int n;printf("fork program starting\n");pid = fork();if (pid == -1){perror("fork failed");exit(1);}else if (pid == 0){message = "I am son";nice(5);n = 5;}else{message = "I am father";n = 4;pid = fork();if (pid == -1){perror("fork failed");exit(1);}else if (pid == 0){message = "I am daughter";nice(10);n = 3;}}for (;n>0;n--){puts(message);sleep(1);}exit(0);//wait.c#include <sys/types.h>#include <unistd.h>#include <stdio.h>#include <stdlib.h>#include <sys/wait.h>int main(){pid_t pid;char *message;int n;int exit_code;printf("fork program starting\n");pid = fork();if (pid == -1){perror("fork failed");exit(1);}else if (pid == 0){message = "I am son";n = 2;exit_code = 42;}else{message = "I am father";n = 1;exit_code = 0;pid = fork();if (pid == -1){perror("fork failed");exit(1);}else if (pid == 0){message = "I am daughter";n = 3;exit_code = 43;}}for (;n>0;n--){puts(message);sleep(1);}if(pid !=0){int stat_val;pid_t child_pid;child_pid = wait(&stat_val);printf("child has finished: PID = %d\n",child_pid);if(WIFEXITED(stat_val))printf("child exited with code %d\n",WEXITSTATUS(stat_val));elseprintf("child terminated abnormally");}exit(exit_code);}。
进程控制实验报告
进程控制实验报告进程控制实验报告一、实验目的本实验旨在通过实际操作，深入理解进程控制的概念、原理和实现方式，掌握进程控制的技巧和方法，提升解决实际问题的能力。
二、实验原理进程控制是操作系统内核的重要功能之一，它负责协调和管理系统中多个进程的执行顺序和资源分配。
进程控制的主要任务包括创建和终止进程、进程切换和进程同步等。
本实验将通过具体的操作，学习和体验进程控制的过程和细节。
三、实验步骤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;}```### 实验总结通过本次实验，我对操作系统进程控制有了更深入的了解。
进程的管理和控制实验报告
进程的管理和控制实验报告实验目的：本实验旨在了解进程的管理和控制，掌握进程的创建、终止和状态转换等操作，并通过实际的代码编写和运行实验，加深对进程管理的理解。
实验原理：在操作系统中，进程是执行中的程序的实例。
进程管理涉及到创建新进程、终止现有进程、管理进程的状态等操作。
进程的创建：进程的创建可以通过系统调用fork()来完成。
fork()系统调用会创建一个新的进程，称为子进程，子进程将继承父进程的代码、数据和资源。
通过fork()的返回值来区分父子进程，父进程返回子进程的进程ID，子进程返回0。
进程的终止：进程的终止可以通过系统调用exit()来完成。
exit()系统调用会终止当前进程的执行，并返回一个退出状态码。
一个进程的终止也可以由其他进程通过发送终止信号来实现。
进程的状态转换：进程在执行过程中会经历不同的状态，包括就绪态、运行态、阻塞态等。
进程的状态转换可以通过系统调用来实现。
例如，当进程被阻塞时，可以通过系统调用sleep()将其状态转换为阻塞态，当等待的事件发生时，再将其状态转换为就绪态。
实验步骤：1. 编写一个简单的程序，包含进程的创建、终止和状态转换等操作。
2. 使用fork()系统调用创建子进程，并在子进程中执行一段代码。
3. 在父进程中对子进程进行管理，包括等待子进程的终止和获取子进程的退出状态码。
4. 在子进程中通过exit()系统调用终止进程的执行。
5. 在父进程中通过wait()系统调用等待子进程的终止，并获取子进程的退出状态码。
6. 在子进程中通过系统调用sleep()将进程的状态转换为阻塞态。
7. 在父进程中发送终止信号给子进程，观察子进程的终止情况。
实验结果与分析：经过实验，我们成功地创建了子进程并在子进程中执行了一段代码。
父进程能够正确地等待子进程的终止并获取子进程的退出状态码。
在子进程中使用sleep()系统调用后，观察到子进程的状态转换为阻塞态。
当父进程发送终止信号给子进程时，子进程能够正确地终止执行。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验一、进程控制实验一、实验目的1、熟悉C语言的编程环境TurboC2、培养学生把抽象的概念、原理转化成具体的、可以运行的程序的能力3、通过实验使学生深入认识进程的含义及各种控制原语的实现过程，也为下面的实验做好准备工作二、实验内容进程控制块：进程控制块（PCB）是系统感知进程存在的唯一标志。
所谓创建进程，实质上是创建进程实体中的PCB，撤销进程实质上是撤销进程的PCB。
本实验规定进程控制块包含以下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
其中进程名这里指它的外部标识符，在创建进程时由用户指定。
进程的优先数及需要的运行时间可以事先人为地指定。
进程运行时间以时间片为单位进行计算。
进程的到达时间为进程创建的时间。
每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。
本实验要求用C语言编程实现创建n个进程的创建函数creat；根据进程的优先数把就绪进程插入就绪队列的排序函数sort；打印就绪进程PCB信息的函数check；以及进程的撤销函数destroy。
实验二、进程调度实验一、目的要求用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解．二、例题：设计一个有 N个进程共行的进程调度程序。
进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。
就绪进程获得 CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止。
进程调度源程序如下：jingchendiaodu.cpp#include "stdio.h"#include <stdlib.h>#include <conio.h>#define getpch(type) (type*)malloc(sizeof(type))#define NULL 0struct pcb { /* 定义进程控制块PCB */char name[10];char state;int super;int ntime;int rtime;struct pcb* link;}*ready=NULL,*p;typedef struct pcb PCB;sort() /* 建立对进程进行优先级排列函数*/{PCB *first, *second;int insert=0;if((ready==NULL)||((p->super)>(ready->super))) /*优先级最大者,插入队首*/{p->link=ready;ready=p;}else /* 进程比较优先级,插入适当的位置中*/{first=ready;second=first->link;while(second!=NULL){if((p->super)>(second->super)) /*若插入进程比当前进程优先数大,*/{ /*插入到当前进程前面*/p->link=second;first->link=p;second=NULL;insert=1;}else /* 插入进程优先数最低,则插入到队尾*/{first=first->link;second=second->link;}}if(insert==0) first->link=p;}}input() /* 建立进程控制块函数*/{int i,num;clrscr(); /*清屏*/printf("\n 请输入进程号?");scanf("%d",&num);for(i=0;i<num;i++){printf("\n 进程号No.%d:\n",i);p=getpch(PCB);printf("\n 输入进程名:");scanf("%s",p->name);printf("\n 输入进程优先数:");scanf("%d",&p->super);printf("\n 输入进程运行时间:");scanf("%d",&p->ntime);printf("\n");p->rtime=0;p->state='w';p->link=NULL;sort(); /* 调用sort函数*/}}int space(){int l=0; PCB* pr=ready;while(pr!=NULL){l++;pr=pr->link;}return(l);}disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/ {printf("\n qname \t state \t super \t ndtime \t runtime \n"); printf("|%s\t",pr->name);printf("|%c\t",pr->state);printf("|%d\t",pr->super);printf("|%d\t",pr->ntime);printf("|%d\t",pr->rtime);printf("\n");}check() /* 建立进程查看函数*/{PCB* pr;printf("\n **** 当前正在运行的进程是:%s",p->name); /*显示当前运行进程*/disp(p);pr=ready;printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/while(pr!=NULL){disp(pr);pr=pr->link;}}destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/{printf("\n 进程[%s] 已完成.\n",p->name);free(p);}running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/{(p->rtime)++;if(p->rtime==p->ntime)destroy(); /* 调用destroy函数*/else{(p->super)--;p->state='w';sort(); /*调用sort函数*/}}main() /*主函数*/{int len,h=0;char ch;input();len=space();while((len!=0)&&(ready!=NULL)){ch=getchar();h++;printf("\n The execute number:%d \n",h);p=ready;ready=p->link;p->link=NULL;p->state='R';check();running();printf("\n 按任一键继续......");ch=getchar();}printf("\n\n 进程已经完成.\n");ch=getchar();}三．实验题：1、编写并调试一个模拟的进程调度程序，采用“最高优先数优先”调度算法对五个进程进行调度。
“最高优先数优先”调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程。
优先数是在创建进程时确定的，并在整个进程运行期间不再改变。
动态优先数是指进程的优先数在创建进程时可以给定一个初始值，并且可以按一定原则修改优先数。
例如：在进程获得一次CPU后就将其优先数减少1。
或者，进程等待的时间超过某一时限时增加其优先数的值，等等2、编写并调试一个模拟的进程调度程序，采用“轮转法”调度算法对五个进程进行调度。
轮转法可以是简单轮转法、可变时间片轮转法，或多队列轮转法。
简单轮转法的基本思想是：所有就绪进程按FCFS排成一个队列，总是把处理机分配给队首的进程，各进程占用CPU的时间片相同。
如果运行进程用完它的时间片后还为完成，就把它送回到就绪队列的末尾，把处理机重新分配给队首的进程。
直至所有的进程运行完毕。
调度算法的流程图如下：实验三、作业调度实验一. 目的要求：用高级语言编写和调试一个或多个作业调度的模拟程序，以加深对作业调度算法的理解。
二. 例题：为单道批处理系统设计一个作业调度程序由于在单道批处理系统中，作业一投入运行，它就占有计算机的一切资源直到作业完成为止，因此调度作业时不必考虑它所需要的资源是否得到满足，它所占用的CPU时限等因素。
作业调度算法：采用先来先服务（FCFS）调度算法，即按作业提交的先后次序进行调度。
总是首先调度在系统中等待时间最长的作业。
每个作业由一个作业控制块JCB表示，JCB可以包含如下信息：作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。
作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。
每个作业的最初状态总是等待W。
各个等待的作业按照提交时刻的先后次序排队，总是首先调度等待队列中队首的作业。
每个作业完成后要打印该作业的开始运行时刻、完成时刻、周转时间和带权周转时间，这一组作业完成后要计算并打印这组作业的平均周转时间、带权平均周转时间。
三. 实习题：1、编写并调试一个单道处理系统的作业等待模拟程序。
作业等待算法：分别采用先来先服务（FCFS），最短作业优先（SJF）、响应比高者优先（HRN）的调度算法。
对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间，以及这组作业的平均周转时间及带权平均周转时间，以比较各种算法的优缺点。
2、编写并调度一个多道程序系统的作业调度模拟程序。
作业调度算法：采用基于先来先服务的调度算法。