进程调度程序设计报告(源代码)剖析

合集下载

进程调度程序实验报告

一、实验目的通过本次实验，加深对进程调度原理和算法的理解，掌握进程调度程序的设计与实现方法。

实验要求我们使用高级编程语言编写一个简单的进程调度程序，实现不同调度算法的模拟，并通过实验验证算法的性能。

二、实验环境1. 操作系统：Windows 102. 编程语言：Java3. 开发工具：IntelliJ IDEA三、实验内容本次实验主要实现以下调度算法：1. 先来先服务（FCFS）2. 最短作业优先（SJF）3. 时间片轮转（RR）四、实验步骤1. 定义进程类（Process）：```javapublic class Process {private String processName; // 进程名称private int arrivalTime; // 到达时间private int burstTime; // 运行时间private int waitingTime; // 等待时间private int turnaroundTime; // 周转时间// 构造函数public Process(String processName, int arrivalTime, int burstTime) {this.processName = processName;this.arrivalTime = arrivalTime;this.burstTime = burstTime;}// 省略getter和setter方法}```2. 定义调度器类（Scheduler）：```javapublic class Scheduler {private List<Process> processes; // 进程列表private int currentTime; // 当前时间// 构造函数public Scheduler(List<Process> processes) {this.processes = processes;this.currentTime = 0;}// FCFS调度算法public void fcfs() {for (Process process : processes) {process.setWaitingTime(currentTime -process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime -process.getArrivalTime());}}// SJF调度算法public void sjf() {processes.sort((p1, p2) -> p1.getBurstTime() -p2.getBurstTime());for (Process process : processes) {process.setWaitingTime(currentTime -process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime -process.getArrivalTime());}}// RR调度算法public void rr(int quantum) {List<Process> sortedProcesses = new ArrayList<>(processes);sortedProcesses.sort((p1, p2) -> p1.getArrivalTime() -p2.getArrivalTime());int timeSlice = quantum;for (Process process : sortedProcesses) {if (process.getBurstTime() > timeSlice) {process.setWaitingTime(currentTime - process.getArrivalTime());currentTime += timeSlice;process.setTurnaroundTime(currentTime - process.getArrivalTime());process.setBurstTime(process.getBurstTime() - timeSlice);} else {process.setWaitingTime(currentTime - process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime - process.getArrivalTime());process.setBurstTime(0);}}}}```3. 测试调度程序：```javapublic class Main {public static void main(String[] args) {List<Process> processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P3", 4, 2));processes.add(new Process("P4", 6, 4));Scheduler scheduler = new Scheduler(processes); System.out.println("FCFS调度结果：");scheduler.fcfs();for (Process process : processes) {System.out.println(process);}processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P2", 1, 3));processes.add(new Process("P3", 4, 2));processes.add(new Process("P4", 6, 4));System.out.println("SJF调度结果：");scheduler.sjf();for (Process process : processes) {System.out.println(process);}processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P2", 1, 3));processes.add(new Process("P3", 4, 2));System.out.println("RR调度结果（时间片为2）：");scheduler.rr(2);for (Process process : processes) {System.out.println(process);}}}```五、实验结果与分析通过实验，我们可以观察到以下结果：1. FCFS调度算法简单，但可能导致长作业等待时间过长。

实验一、进程调度实验报告

实验一、进程调度实验报告一、实验目的进程调度是操作系统中的核心功能之一，其目的是合理地分配 CPU 资源给各个进程，以提高系统的整体性能和资源利用率。

通过本次实验，我们旨在深入理解进程调度的原理和算法，掌握进程状态的转换，观察不同调度策略对系统性能的影响，并通过实际编程实现来提高我们的编程能力和对操作系统概念的理解。

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

三、实验原理1、进程状态进程在其生命周期中会经历不同的状态，包括就绪态、运行态和阻塞态。

就绪态表示进程已经准备好执行，只等待 CPU 分配；运行态表示进程正在 CPU 上执行；阻塞态表示进程由于等待某个事件（如 I/O操作完成）而暂时无法执行。

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

先来先服务算法按照进程到达的先后顺序进行调度。

短作业优先算法优先调度执行时间短的进程。

时间片轮转算法将 CPU 时间划分成固定大小的时间片，每个进程轮流获得一个时间片执行。

四、实验内容1、设计并实现一个简单的进程调度模拟器定义进程结构体，包含进程 ID、到达时间、执行时间、剩余时间等信息。

实现进程的创建、插入、删除等操作。

实现不同的调度算法。

2、对不同调度算法进行性能测试生成一组具有不同到达时间和执行时间的进程。

分别采用先来先服务、短作业优先和时间片轮转算法进行调度。

记录每个算法下的平均周转时间、平均等待时间等性能指标。

五、实验步骤1、进程结构体的定义｀｀｀c+＋struct Process ｛int pid;int arrivalTime;int executionTime;int remainingTime;int finishTime;int waitingTime;int turnaroundTime;｝；｀｀｀2、进程创建函数｀｀｀c+＋void createProcess(Process processes, int& numProcesses, int pid, int arrivalTime, int executionTime) ｛processesnumProcessespid ＝ pid;processesnumProcessesarrivalTime ＝ arrivalTime;processesnumProcessesexecutionTime ＝ executionTime;processesnumProcessesremainingTime ＝ executionTime;numProcesses+＋；｝｀｀｀3、先来先服务调度算法实现｀｀｀c+＋void fcfsScheduling(Process processes, int numProcesses) ｛int currentTime ＝ 0;for （int i ＝ 0; i ＜ numProcesses; i+＋）｛if （currentTime ＜ processesiarrivalTime) ｛currentTime ＝ processesiarrivalTime;｝processesistartTime ＝ currentTime;currentTime ＋＝ processesiexecutionTime;processesifinishTime ＝ currentTime;processesiwaitingTime ＝ processesistartTime processesiarrivalTime;processesiturnaroundTime ＝ processesifinishTime processesiarrivalTime;｝｝｀｀｀4、短作业优先调度算法实现｀｀｀c+＋void sjfScheduling(Process processes, int numProcesses) ｛int currentTime ＝ 0;int minExecutionTime, selectedProcess;bool found;while （true) ｛found ＝ false;minExecutionTime ＝ INT_MAX;selectedProcess ＝－1;for （int i ＝ 0; i ＜ numProcesses; i+＋）｛if （processesiarrivalTime ＜＝ currentTime ＆＆processesiremainingTime ＜ minExecutionTime ＆＆processesiremainingTime ＞ 0) ｛found ＝ true;minExecutionTime ＝ processesiremainingTime;selectedProcess ＝ i;｝｝if （！found) ｛break;｝processesselectedProcessstartTime ＝ currentTime;currentTime ＋＝ processesselectedProcessremainingTime;processesselectedProcessfinishTime ＝ currentTime;processesselectedProcesswaitingTime ＝processesselectedProcessstartTime processesselectedProcessarrivalTime;processesselectedProcessturnaroundTime ＝processesselectedProcessfinishTime processesselectedProcessarrivalTime;processesselectedProcessremainingTime ＝ 0;｝｝｀｀｀5、时间片轮转调度算法实现｀｀｀c+＋void rrScheduling(Process processes, int numProcesses, int timeSlice) ｛int currentTime ＝ 0;Queue<int> readyQueue;for （int i ＝ 0; i ＜ numProcesses; i+＋）｛readyQueueenqueue(i)；｝while （！readyQueueisEmpty(））｛int currentProcess ＝ readyQueuedequeue(）；if （processescurrentProcessarrivalTime ＞ currentTime) ｛currentTime ＝ processescurrentProcessarrivalTime;｝if （processescurrentProcessremainingTime ＜＝ timeSlice) ｛currentTime ＋＝ processescurrentProcessremainingTime;processescurrentProcessfinishTime ＝ currentTime;processescurrentProcesswaitingTime ＝processescurrentProcessstartTime processescurrentProcessarrivalTime;processescurrentProcessturnaroundTime ＝processescurrentProcessfinishTime processescurrentProcessarrivalTime;processescurrentProcessremainingTime ＝ 0;｝ else ｛currentTime ＋＝ timeSlice;processescurrentProcessremainingTime ＝ timeSlice;readyQueueenqueue(currentProcess)；｝｝｝｀｀｀6、性能指标计算函数｀｀｀c+＋void calculatePerformanceMetrics(Process processes, int numProcesses, double& averageWaitingTime, double& averageTurnaroundTime) ｛double totalWaitingTime ＝ 0, totalTurnaroundTime ＝ 0;for （int i ＝ 0; i ＜ numProcesses; i+＋）｛totalWaitingTime ＋＝ processesiwaitingTime;totalTurnaroundTime ＋＝ processesiturnaroundTime;｝averageWaitingTime ＝ totalWaitingTime ／ numProcesses; averageTurnaroundTime ＝ totalTurnaroundTime ／ numProcesses;｝｀｀｀7、主函数｀｀｀c+＋int main(）｛Process processes100;int numProcesses ＝ 0;／／创建进程createProcess(processes, numProcesses, 1, 0, 5)；createProcess(processes, numProcesses, 2, 1, 3)；createProcess(processes, numProcesses, 3, 2, 4)；createProcess(processes, numProcesses, 4, 3, 2)；／／先来先服务调度fcfsScheduling(processes, numProcesses)；double fcfsAverageWaitingTime, fcfsAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, fcfsAverageWaitingTime, fcfsAverageTurnaroundTime)；cout ＜＜＂先来先服务调度的平均等待时间：＂＜＜fcfsAverageWaitingTime ＜＜ endl;cout ＜＜＂先来先服务调度的平均周转时间：＂＜＜fcfsAverageTurnaroundTime ＜＜ endl;／／短作业优先调度sjfScheduling(processes, numProcesses)；double sjfAverageWaitingTime, sjfAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, sjfAverageWaitingTime, sjfAverageTurnaroundTime)；cout ＜＜＂短作业优先调度的平均等待时间：＂＜＜sjfAverageWaitingTime ＜＜ endl;cout ＜＜＂短作业优先调度的平均周转时间：＂＜＜sjfAverageTurnaroundTime ＜＜ endl;／／时间片轮转调度（时间片为 2）rrScheduling(processes, numProcesses, 2)；double rrAverageWaitingTime, rrAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, rrAverageWaitingTime, rrAverageTurnaroundTime)；cout ＜＜＂时间片轮转调度（时间片为 2）的平均等待时间：＂＜＜ rrAverageWaitingTime ＜＜ endl;cout ＜＜＂时间片轮转调度（时间片为 2）的平均周转时间：＂＜＜ rrAverageTurnaroundTime ＜＜ endl;return 0;｝｀｀｀六、实验结果与分析1、先来先服务调度平均等待时间：40平均周转时间：85分析：先来先服务调度算法简单直观，但对于短作业可能会造成较长的等待时间，导致平均等待时间和平均周转时间较长。

进程管理实验报告源代码(3篇)

第1篇---进程管理实验报告一、实验目的1. 理解进程的概念和进程管理的基本原理。

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

3. 通过编程实现简单的进程管理功能。

二、实验环境1. 操作系统：Windows/Linux2. 编程语言：C/C++3. 开发环境：Visual Studio/Code::Blocks三、实验内容1. 进程的创建与终止2. 进程的同步与互斥3. 进程的通信4. 进程调度算法四、实验步骤1. 进程的创建与终止```cinclude <stdio.h>include <sys/types.h>include <unistd.h>int main() {pid_t pid;// 创建子进程pid = fork();if (pid < 0) {// 创建进程失败perror("fork failed");return 1;} else if (pid == 0) {// 子进程printf("Child process, PID: %d\n", getpid()); // 执行子进程的任务...sleep(5); // 子进程暂停5秒_exit(0); // 子进程退出} else {// 父进程printf("Parent process, PID: %d\n", getpid()); wait(NULL); // 等待子进程结束printf("Child process has terminated.\n");}return 0;}```2. 进程的同步与互斥```cinclude <stdio.h>include <pthread.h>pthread_mutex_t mutex;void thread_func(void arg) {pthread_mutex_lock(&mutex); // 加锁printf("Thread %ld is running\n", (long)arg);sleep(1); // 模拟任务执行pthread_mutex_unlock(&mutex); // 解锁return NULL;}int main() {pthread_t thread1, thread2;// 初始化互斥锁pthread_mutex_init(&mutex, NULL);// 创建线程pthread_create(&thread1, NULL, thread_func, (void )1); pthread_create(&thread2, NULL, thread_func, (void )2); // 等待线程结束pthread_join(thread1, NULL);pthread_join(thread2, NULL);// 销毁互斥锁pthread_mutex_destroy(&mutex);return 0;}```3. 进程的通信```cinclude <stdio.h>include <stdlib.h>include <sys/ipc.h>include <sys/shm.h>int main() {key_t key;int shmid;int data;// 生成共享内存标识符key = ftok("shmfile", 65);// 创建共享内存段shmid = shmget(key, sizeof(int), 0666 | IPC_CREAT); if (shmid == -1) {perror("shmget failed");exit(1);}// 连接到共享内存段data = (int )shmat(shmid, (void )0, 0);if (data == (int )(-1)) {perror("shmat failed");exit(1);}// 使用共享内存data = 100;printf("Data in shared memory: %d\n", data); // 分离共享内存段if (shmdt(data) == -1) {perror("shmdt failed");exit(1);}// 删除共享内存段if (shmctl(shmid, IPC_RMID, NULL) == -1) { perror("shmctl failed");exit(1);}return 0;}```4. 进程调度算法```cinclude <stdio.h>include <stdlib.h>include <sys/time.h>typedef struct {int pid;int arrival_time;int burst_time;int waiting_time;int turnaround_time;} Process;int main() {Process processes[] = {{1, 0, 5, 0, 0},{2, 1, 3, 0, 0},{3, 4, 8, 0, 0}};int n = sizeof(processes) / sizeof(processes[0]);// 计算等待时间和周转时间int total_waiting_time = 0, total_turnaround_time = 0;for (int i = 0; i < n; i++) {if (i == 0) {processes[i].waiting_time = 0;} else {processes[i].waiting_time = processes[i - 1].turnaround_time;}processes[i].turnaround_time = processes[i].burst_time + processes[i].waiting_time;total_waiting_time += processes[i].waiting_time;total_turnaround_time += processes[i].turnaround_time;}printf("Average Waiting Time: %f\n", (float)total_waiting_time / n);printf("Average Turnaround Time: %f\n", (float)total_turnaround_time / n);return 0;}```五、实验结果与分析（此处应填写实验结果，包括运行程序输出、图表等，以及对实验结果的分析。

进程调度报告

一、实验目的通过对进程调度算法的模拟加深对进程概念和进程调度算法的理解。

二、实验要求编写程序实现对5个进程的调度模拟，要求至少采用两种不同的调度算法分别进行模拟调度。

三、实验方法内容1.算法设计思路将每个进程抽象成一个控制块PCB，PCB用一个结构体描述。

构建一个进程调度类。

将进程调度的各种算法分装在一个类中。

类中存在三个容器，一个保存正在或未进入就绪队列的进程，一个保存就绪的进程，另一个保存已完成的进程。

还有一个PCB实例。

主要保存正在运行的进程。

类中其他方法都是围绕这三个容器可以这个运行中的PCB展开。

主要用到的技术是STL中的vector以维护和保存进程容器、就绪容器、完成容器。

当程序启动时，用户可以选择不同的调度算法。

然后用户从控制台输入各个进程的信息，这些信息保存到进程容器中。

进程信息输入完毕后，就开始了进程调度，每调度一次判断就绪队列是否为空，若为空则系统时间加一个时间片。

判断进程容器中是否有新的进程可以加入就绪队列。

2.算法流程图主程序的框架：开始选择调度算法void FCFS();//先来先服务void SJF();//最短进程优先调度void RR();//简单时间片轮转void PD();//最高优先数优先输入进程信息将输入容器中以满足进入条件的进程调入就绪队列判断就绪容器和输入容器是否为空!processScheduler.m_WaitQueue.empty()|| !processScheduler.m_ProcessQueue.empt() void ProcessQueueProcess();//查看当前时间下，有无进程加入。

若有则把该进程调入就绪队列void PCBInput();//输入进程信息Y打印各进程信息进行统计计算周转时间等结束void PCBDisplay();//打印当前状况下。

就绪队列、完成队列、运行中的进程信息void SchedulerStatistics();//调度统计，计算周转时间等按照选择的算法开始选择就绪队列的进程开始执行void ProcessSelect();//若当前就绪队列不为空则根据选择的调度算法开始调度,否则，系统时间加一个时间片.以等待新的进程到设计思路：（1）设计就绪、执行、完成三个队列；根据输入进程的时间，按照需要的时间越多，优先级越低,（60减去所需时间）建立就绪队列。

进程的调度实验报告(3篇)

第1篇一、实验目的通过本次实验，加深对操作系统进程调度原理的理解，掌握先来先服务（FCFS）、时间片轮转（RR）和动态优先级（DP）三种常见调度算法的实现，并能够分析这些算法的优缺点，提高程序设计能力。

二、实验环境- 编程语言：C语言- 操作系统：Linux- 编译器：GCC三、实验内容本实验主要实现以下内容：1. 定义进程控制块（PCB）结构体，包含进程名、到达时间、服务时间、优先级、状态等信息。

2. 实现三种调度算法：FCFS、RR和DP。

3. 创建一个进程队列，用于存储所有进程。

4. 实现调度函数，根据所选算法选择下一个执行的进程。

5. 模拟进程执行过程，打印进程执行状态和就绪队列。

四、实验步骤1. 定义PCB结构体：```ctypedef struct PCB {char processName[10];int arrivalTime;int serviceTime;int priority;int usedTime;int state; // 0: 等待，1: 运行，2: 完成} PCB;```2. 创建进程队列：```cPCB processes[MAX_PROCESSES]; // 假设最多有MAX_PROCESSES个进程int processCount = 0; // 实际进程数量```3. 实现三种调度算法：（1）FCFS调度算法：```cvoid fcfsScheduling() {int i, j;for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程：%s\n", processes[i].processName); processes[i].usedTime++;if (processes[i].usedTime == processes[i].serviceTime) { processes[i].state = 2; // 设置为完成状态printf("进程：%s 完成\n", processes[i].processName); }for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```（2）RR调度算法：```cvoid rrScheduling() {int i, j, quantum = 1; // 时间片for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程：%s\n", processes[i].processName); processes[i].usedTime++;processes[i].serviceTime--;if (processes[i].serviceTime <= 0) {processes[i].state = 2; // 设置为完成状态printf("进程：%s 完成\n", processes[i].processName); } else {processes[i].arrivalTime++;}for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```（3）DP调度算法：```cvoid dpScheduling() {int i, j, minPriority = MAX_PRIORITY;int minIndex = -1;for (i = 0; i < processCount; i++) {if (processes[i].arrivalTime <= 0 && processes[i].priority < minPriority) {minPriority = processes[i].priority;minIndex = i;}}if (minIndex != -1) {processes[minIndex].state = 1; // 设置为运行状态printf("正在运行进程：%s\n", processes[minIndex].processName);processes[minIndex].usedTime++;processes[minIndex].priority--;processes[minIndex].serviceTime--;if (processes[minIndex].serviceTime <= 0) {processes[minIndex].state = 2; // 设置为完成状态printf("进程：%s 完成\n", processes[minIndex].processName); }}}```4. 模拟进程执行过程：```cvoid simulateProcess() {printf("请选择调度算法（1：FCFS，2：RR，3：DP）：");int choice;scanf("%d", &choice);switch (choice) {case 1:fcfsScheduling();break;case 2:rrScheduling();break;case 3:dpScheduling();break;default:printf("无效的调度算法选择。

操作系统(进程调度)实验报告

操作系统原理（进程调度）实验报告实验一：动态优先权一．实验目的：（1）.理解进程创建的相关理论；（2）.掌握进程创建方法；（3）.掌握进程相关的数据结构；（4）.了解进程的调度算法；二．实验内容：1、最好采用图形界面；2、可随时增加进程；3、规定道数，设置后备队列和挂起状态。

若内存中进程少于规定道数，可自动从后备队列调度一作业进入。

被挂起进程入挂起队列，设置解挂功能用于将指定挂起进程解挂入就绪队列。

4、每次调度后，显示各进程状态。

三．实验步骤1.创建进程PCB。

包括进程ID，优先权，执行时间，占用cpu时间，状态五个部分；struct Process{int id;int priority;int cputime;int alltime;enum STATE state;}process[N];2.初始化进程队列。

进程号用ID表示，优先权随机设定，状态均置为ready；void Init(){srand((unsigned)time(NULL));for(int i=0;i<N;i++){process[i].id = Rseq[i] = i;process[i].priority = rand()%20;process[i].cputime = 0;process[i].alltime = rand()%3+3;process[i].state = ready;TIME += process[i].alltime;}Sort();Print();flag = 1;}3.运行进程。

首轮按优先权大小排列进程执行顺序，优先权最大的最先执行，首轮执行后，运行程序优先权减2，未执行程序优先权加1.第二轮再按优先权顺序排序执行，以此类推，直到所有程序执行完成。

..........附录(源代码)：#include<stdio.h>#include<stdlib.h>#include<time.h>#define N 5enum STATE{ready,run,finish};struct Process{int id;int priority;int cputime;int alltime;enum STATE state;}process[N];int Rseq[N];int flag = 0;int TIME = 0;void Print(){printf("=============================================================\n");printf(" id priority cputime alltime state \n");for(int i=0;i<N;i++){printf(" %d %d %d %d",process[i].id,process[i].priority,process[i].cputime,process[i].alltime);switch(process[i].state){case 0:printf("ready\n");break;case 1:printf("run\n");break;case 2:printf("finish\n");}}printf(" Next Run sequence :");for(int i=0;i<N;i++)if(i != N-1)printf("%d -> ",Rseq[i]);else printf("%d\n",Rseq[i]);printf("=============================================================\n\n"); }void Sort(){int temp;for(int i=0;i<N-1;i++)for(int j=i+1;j<N;j++)if(process[Rseq[i]].priority <= process[Rseq[j]].priority){temp = Rseq[i];Rseq[i] = Rseq[j];Rseq[j] = temp;}}void Init(){srand((unsigned)time(NULL));for(int i=0;i<N;i++){process[i].id = Rseq[i] = i;process[i].priority = rand()%20;process[i].cputime = 0;process[i].alltime = rand()%3+3;process[i].state = ready;TIME += process[i].alltime;}Sort();Print();flag = 1;}void Run(){for(int i=0;i<=TIME;i++){printf(" run process:%d\n",Rseq[0]);for(int j=0;j<N;j++){if(process[j].state == run) process[j].state = ready;}for(int j=0;j<N;j++){if(process[Rseq[j]].alltime == 0){process[Rseq[j]].priority = 0;process[Rseq[j]].state = finish;}else if(j == 0 && process[Rseq[j]].alltime != 0){process[Rseq[j]].priority -= 2;process[Rseq[j]].cputime++;process[Rseq[j]].alltime--;process[Rseq[j]].state = run ;}else process[Rseq[j]].priority++;}Sort();Print();}}main(){Init();Run();}实验二：循环首次适应法（一）需求分析该算法是首次适应算法的变种。

操作系统进程调度实验报告1

一、实验目的通过对进程调度算法的模拟加深对进程概念和进程调度算法的理解。

二、实验要求编写程序实现对5个进程的调度模拟，要求至少采用两种不同的调度算法（先来先服务算法，短作业算法）分别进行模拟调度。

三、实验内容编程实现如下算法1．先来先服务算法；2．短作业算法四、实验代码1．先来先服务算法#include"stdio.h"#include"stdlib.h"typedef struct PCB //定义进程控制块{ char name[10]; //进程名char state; //运行状态int ArriveTime; //到达时间int StartTime; //进程开始时间int FinishTime; //进程结束时间int ServiceTime; //服务时间float WholeTime; //周转时间float WeightWholeTime;//带权周转时间double AverageWT_FCFS; //平均周转时间double AverageWWT_FCFS;//带权平均周转时间struct PCB *next; //指向下个进程}pcb;double x=0,y=0;int i;int time; //计时器int n; //进程个数pcb *head=NULL,*p,*q; //进程链表指针void run_FCFS(pcb *p1) //运行未完成的进程{time = p1->ArriveTime > time? p1->ArriveTime:time;p1->StartTime=time;printf("\n时刻：%d, 当前开始运行作业%s\n\n",time,p1->name);time+=p1->ServiceTime;p1->state='T';p1->FinishTime=time;p1->WholeTime=p1->FinishTime-p1->ArriveTime;p1->WeightWholeTime=p1->WholeTime/p1->ServiceTime;x+=p1->WholeTime;y+=p1->WeightWholeTime;p1->AverageWT_FCFS=p1->WholeTime/n;p1->AverageWWT_FCFS=p1->WeightWholeTime/n;printf(" 到达时间开始时间服务时间完成时间周转时间带权周转时间\n");printf("%6d %10d %10d %8d %10.1f %10.2f \n ",p1->ArriveTime,p1->StartTime,p1->ServiceTime,p1->FinishTime,p1->WholeTime,p1->WeightWholeTime);printf("\n平均周转时间平均带权周转时间\n");printf(" %10.2f %10.2f\n ",p1->AverageWT_FCFS,p1->AverageWWT_FCFS);}void FCFS() //找到当前未完成的进程{int i;p=head;for(i=0;i<n;i++){if(p->state=='F'){ q=p; //标记当前未完成的进程run_FCFS(q);}p=p->next;}}void getInfo() //获得进程信息并创建进程{int num;printf("\n进程个数:");scanf("%d",&n);for(num=0;num<n;num++){p=(pcb *)malloc(sizeof(pcb));printf("依次输入：\n进程名到达时间服务时间\n");scanf("%s\t%d\t%d",&p->name,&p->ArriveTime,&p->ServiceTime);if(head==NULL){head=p;q=p;time=p->ArriveTime;}if(p->ArriveTime < time)time=p->ArriveTime;q->next=p;p->StartTime=0;p->FinishTime=0;p->WholeTime=0;p->WeightWholeTime=0;p->next=NULL;p->state='F';q=p;}}void main(){printf("先来先服务FCFS算法模拟\n");getInfo();p=head;FCFS();}2．短作业调度算法#include<iostream>#include<stdio.h>#include<iomanip>#include<queue>#include<deque>using namespace std;class JCB{public:int start,end,arrive,runtime,zhou,weizhou;string name;char state;void Show(){cout.width(9);cout<<name;cout.width(9);cout<<arrive;cout.width(11);cout<<runtime;cout.width(13);cout<<start;cout.width(10);cout<<end;cout.width(10);cout<<zhou;cout.width(9);cout<<(double)zhou/runtime<<endl;}bool operator<(const JCB& node)const{return arrive<node.arrive;}};int main(){int num;deque<JCB> Q;JCB jcb;cout<<"（SJF）请输入作业数目：";cin>>num;for(int i=1; i<=num; i++){cout<<"\n请输入作业名，到达时间，运行时间：";cin>>>>jcb.arrive>>jcb.runtime;jcb.state='W';Q.push_back(jcb);}deque<JCB>::iterator it,jt,current;current=Q.begin();current->start=current->arrive;current->end=current->start+current->runtime;current->zhou=current->end-current->arrive;current->state='R';for(int i=2; i<=num; i++){int flag=0;for(it=Q.begin(); it!=Q.end(); it++){if(flag==0)for(jt=Q.begin(); jt!=Q.end(); jt++)if(jt->state=='W') break;if(it->state=='W'&&it->arrive<=current->end&&it->runtime<jt->runtime){ jt=it; flag=1;}}if(jt->arrive<=current->end)jt->start=current->end;else jt->start=jt->arrive;jt->end=jt->start+jt->runtime;jt->zhou=jt->end-jt->arrive;jt->state='R';current=jt;}cout<<"\n作业名到达时间服务时间开始执行时间完成时间周转时间带权周转时间"<<endl;cout.setf(ios::left);double sum=0;while(!Q.empty()){jcb=Q.front();jcb.Show();sum+=(double )jcb.zhou/jcb.runtime;Q.pop_front();}cout<<"\n短作业优先算法(SJF)平均带权周转时间："<<sum/num<<endl;return 0;}五、实验结果1.执行结果2.结果分析先来先服务调度算法就是根据进程达到的时间为依据，哪一个进程先来那么该进程就会先执行；最短进程优先调度算法则是以每个进程执行所需时间长短为依据，某一个进程执行所需花的时间要短些那么该进程就先执行。

进程调度程序设计报告(源代码)

课程设计报告题目进程调度程序设计课程名称操作系统课程设计院部名称计算机工程学院专业计算机科学与技术班级 13计算机科学与技术(单)(1)学生姓名周敏健学号 1305201013课程设计地点 A104课程设计学时 20学时指导教师何健金陵科技学院教务处制成绩目录摘要 (3)一、课程设计的目的和要求 (4)二、系统需求分析 (4)三、总体设计 (5)四、详细设计 (6)五、测试、调试过程 (9)六、结论与体会 (11)七、参考文献 (12)附录：源程序 (12)课程设计课题进程调度程序设计摘要在多道系统中，对批处理作业需要进行作业调度。

作业调度是在资源满足的条件下，将处于就绪状态的作业调入存，同时生成与作业相对应的进程，并未这些进程提供所需要的资源。

进程调度需要根据进程控制块（PCB）中的信息，检查系统是否满足进程的资源需求。

只有在满足进程的资源需求的情况下，系统才能进行进程调度。

下面是几种常见的作业调度算法：先来先服务（FCFS）、优先算法、轮换算法、短作业优先算法以及最高响应比优先法等，本文将对前两种算法进行详细的介绍。

关键词：进程调度，优先级，FCFS，PCB，作业，资源一、课程设计的目的和要求1、目的进程调度是处理机管理的核心容。

本设计要求用C语言编写和调试一个简单的进程调度程序。

通过设计本可以加深理解有关进程控制块、进程队列的概念，并体会和了解最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法的具体实施办法。

2、要求1）进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。

2）每个进程有一个进程控制块（PCB）表示。

进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。

3）进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。

北邮操作系统进程管理实验报告及源代码

进程管理实验报告1. 实验目的:（1）加深对进程概念的理解, 明确进程和程序的区别；（2）进一步认识并发执行的实质；（3）分析进程争用资源的现象, 学习解决进程互斥的方法；（4）了解Linux系统中进程通信的基本原理。

2. 实验预备内容（1）阅读Linux的sched.h源码文件, 加深对进程管理概念的理解；（2）阅读Linux的fork()源码文件, 分析进程的创建过程。

3.环境说明本次实验使用的是win7下的VMWare workstation虚拟机, 安装了ubuntu系统在ubuntu系统下使用code::blocks IDE编写代码并执行程序的4.实验内容:1.进程的创建:（1）实验题目和要求:编写一段程序, 使用系统调用fork() 创建两个子进程。

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

让每一个进程在屏幕上显示一个字符：父进程显示字符“a”, 子进程分别显示字符“b”和“c”。

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

（2）程序设计说明:参照书上的例子进行设计, 详见源代码（3）程序运行结果截图:（4）程序分析:a,b,c随机出现, 因为父进程与两个子进程之间并没有同步措施, 所以a,b,c随机打印出来, 也就是三个进程的活动次序是随机进行的, 不同的系统可能有不同的进程调度方式。

（5）源程序:#include<sys/types.h>#include<stdio.h>#include<unistd.h>int main(){pid_t pid1,pid2;if((pid1=fork())<0){printf("Fork Failed.\n");exit(-1);}else if((pid1=fork())==0)printf("b\n");else{if((pid2=fork())<0){printf("Fork Failed.\n");exit(-1);}else if((pid2=fork())==0)printf("c\n");else{wait(NULL);printf("a\n");exit(0);}}return 0;}2.进程的控制:要求一：（1）实验题目和要求:修改已经编写的程序, 将每个进程输出一个字符改为每个进程输出一句话, 再观察程序执行时屏幕上出现的现象, 并分析原因。

操作系统综合性实验报告~进程调度(含代码)

XXXXXX计算机系综合性实验实验报告课程名称操作系统B实验学期XXXX 至XXXX 学年第X 学期学生所在系部计算机系年级XXXX 专业班级XXXXXX学生姓名XXXX 学号XXXXXXXXXXXX任课教师XXX实验成绩计算机系制《操作系统B 》课程综合性实验报告开课实验室：年月日附代码：#include <stdio.h>#include <stdlib.h>#include <string.h>typedef struct node{char name[10]; //进程的名字int round; //一次分配CPU的时间片int cputime; //CPU已执行时间int needtime; //进程执行所需要的时间char state; //进程的状态，W-就绪态，R-执行态，F-完成态int count; //记录进程执行的次数struct node *next; //队列指针}PCB;PCB *ready=NULL,*run=NULL,*finish=NULL; //定义三个队列，就绪队列，执行队列和完成队列int num;void GetFirst(); //从就绪队列取得第一个节点void Output(); //输出各队列信息void InsertTime(PCB *in); //插入就绪片队列void InsertFinish(PCB *in); //插入完成队列void TimeCreate(); //时间片输入函数void RoundRun(); //时间片轮转调度void main(){printf("\n****** 欢迎光临指导******\n");printf("\n****** 时间片轮转进程调度算法******\n");printf("\n****** 计科B082 韩友******\n");printf("\n****** 200807014225 ******\n");printf("\n****** 2011年5月15日******\n");printf("\n请输入要创建的进程数目:\n");scanf("%d",&num);getchar(); //吸收回车符号TimeCreate();RoundRun();Output();}void GetFirst() //取得第一个就绪队列节点{run = ready;if(ready!=NULL){run ->state = 'R';ready = ready ->next;run ->next = NULL;}}void Output() //输出队列信息{PCB *p;p = ready;printf("进程轮数cpu时间需要时间进程状态计数器\n");while(p!=NULL){printf("%s\t%d\t%d\t%d\t%c\t%d\n",p->name,p->round,p->cputime,p->needtime,p->state,p->count);p = p->next;}p = finish;while(p!=NULL){printf("%s\t%d\t%d\t%d\t%c\t%d\n",p->name,p->round,p->cputime,p->needtime,p->state,p->count);p = p->next;}p = run;while(p!=NULL){printf("%s\t%d\t%d\t%d\t%c\t%d\n",p->name,p->round,p->cputime,p->needtime,p->state,p->count);p = p->next;}}void InsertTime(PCB *in) //将进程插入到就绪队列尾部{PCB *fst;fst = ready;if(ready == NULL){in->next = ready;ready = in;}{while(fst->next != NULL){fst = fst->next;}in ->next = fst ->next;fst ->next = in;}}void InsertFinish(PCB *in) //将进程插入到完成队列尾部{PCB *fst;fst = finish;if(finish == NULL){in->next = finish;finish = in;}else{while(fst->next != NULL)fst = fst->next;}in ->next = fst ->next;fst ->next = in;}}void TimeCreate() //时间片轮转输入函数{PCB *tmp;int i;printf("输入进程名字和进程时间片所需时间：\n");for(i = 0;i < num; i++){if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL){perror("malloc");exit(1);}scanf("%s",tmp->name);getchar();scanf("%d",&(tmp->needtime));tmp ->cputime = 0;tmp ->state ='W';tmp ->round = 2; //假设每个进程所分配的时间片是2tmp ->count = 0;InsertTime(tmp);}}void RoundRun() //时间片轮转调度算法{int flag = 1;GetFirst();while(run != NULL){Output();while(flag){run->count++;run->cputime++;run->needtime--;if(run->needtime == 0) //进程执行完毕{run ->state = 'F';InsertFinish(run);flag = 0;}else if(run->count == run->round)//时间片用完{run->state = 'W';run->count = 0; //计数器清零，为下次做准备InsertTime(run);flag = 0;}}flag = 1;GetFirst();}}。

进程调度实验报告

实验二进程调度算法的设计实验目的通过对进程调度算法的设计，深入理解进程调度的原理设计原理LRU：最近最久未使用算法。

流程图源程序源程序如下：#include<iostream>#include<string>#include<stdlib.h>#include<ctime>usingnamespace std;constint Bsize=10;constint Psize=20;struct p{int content;//页面号int timer;//被访问的标记};p block[Bsize];//物理块p page[Psize];//页面号串void Init(int QString[],int Bsize){//初始化for(int i=0; i<Bsize; i++){block[i].content = -1;//找到空闲的内存block[i].timer = 0;}for(int i=0; i<Psize; i++){page[i].content = QString[i];page[i].timer = 0;}}int findSpace(int Bsize){//查找是否还有空闲内存for(int i=0; i<Bsize; i++)if(block[i].content == -1)return i;//找到空闲内存，返回BLOCK中位置return -1;}int findExist(int curpage, int Bsize){//查找内存中是否有该页面?for(int i=0; i<Bsize; i++)if(block[i].content == page[curpage].content)return i;//找到内存中有该页面，返回BLOCK中位置return -1;}int findReplace(int Bsize){//查找应予置换的页面int pos = 0;for(int i=0; i<Bsize; i++)if(block[i].timer >= block[pos].timer)pos = i;//找到应予置换页面，返回BLOCK中位置return pos;}void display(int Bsize){//显示for(int i=0; i<Bsize; i++)if(block[i].content != -1)//非空闲内存cout<<block[i].content<<"";cout<<endl;}void LRU(int Bsize){//最近最久未使用置换算法int exist,space,position ;float score=0;for(int i=0; i<Psize; i++){exist = findExist(i,Bsize);if(exist != -1){block[exist].timer=0;cout<<"不缺页"<<endl;score+=1;}else{space = findSpace(Bsize);if(space != -1){block[space] = page[i];display(Bsize);}else{position = findReplace(Bsize);block[position] = page[i];display(Bsize);}}for(int j=0; j<Bsize; j++)block[j].timer++;//BLOCK中D所¨´有®D页°3面?TIMER++}cout<<"缺页次数为："<<20-score<<endl;cout<<"缺页率为： "<<(20-score)*100/20<<"%"<<endl;}void BlockClear(int Bsize){for(int i=0; i<Bsize; i++){block[i].content = -1;block[i].timer = 0;}}int main(){srand((int)time(NULL));int i,QString[20],Bsize;for(i=0;i<20;i++){QString[i] = rand()%10 ;}cout<<"页面号引用串: ";for(i=0;i<20;i++){cout<<QString[i]<<"";}cout<<endl<<"------------------------------------------------------"<<endl;Bsize = 3;Init(QString,Bsize);cout<<"LRU算法结果如下:<<endl;LRU(Bsize);BlockClear(Bsize);cout<<"----------------------"<<endl;system("pause");}某一次运行结果：。

进程调度实验报告源码

一、实验目的本次实验旨在通过模拟进程调度过程，加深对进程调度算法的理解，并掌握进程调度程序的设计与实现方法。

实验内容主要包括：创建进程、进程调度、进程执行、进程结束等。

二、实验环境操作系统：Linux编程语言：C/C++三、实验内容1. 进程调度算法本实验采用三种进程调度算法：FIFO（先进先出）、时间片轮转法、多级反馈队列调度算法。

2. 进程调度程序设计进程调度程序主要由以下部分组成：（1）进程控制块（PCB）PCB用于描述进程的基本信息，包括进程名、到达时间、需要运行时间、已运行时间、进程状态等。

（2）就绪队列就绪队列用于存储处于就绪状态的进程，按照进程的优先级或到达时间进行排序。

（3）进程调度函数进程调度函数负责从就绪队列中选择一个进程进行执行，并将CPU分配给该进程。

（4）进程执行函数进程执行函数负责模拟进程的执行过程，包括进程的创建、执行、结束等。

四、实验源码```c#include <stdio.h>#include <stdlib.h>#include <time.h>#define MAX_PROCESSES 10typedef struct PCB {int pid;int arrival_time;int need_time;int used_time;int priority;int state; // 0: 等待 1: 运行 2: 完成} PCB;PCB processes[MAX_PROCESSES];int process_count = 0;typedef struct Queue {PCB queue;int front;int rear;int size;} Queue;Queue ready_queue;void init_queue(Queue q) {q->queue = (PCB )malloc(sizeof(PCB) MAX_PROCESSES); q->front = q->rear = 0;q->size = 0;}void enqueue(Queue q, PCB p) {if (q->size == MAX_PROCESSES) {printf("Queue is full.\n");return;}q->queue[q->rear] = p;q->rear = (q->rear + 1) % MAX_PROCESSES; q->size++;}PCB dequeue(Queue q) {if (q->size == 0) {printf("Queue is empty.\n");return NULL;}PCB p = &q->queue[q->front];q->front = (q->front + 1) % MAX_PROCESSES; q->size--;return p;}int is_empty(Queue q) {return q->size == 0;}void print_queue(Queue q) {printf("Queue: ");for (int i = 0; i < q->size; i++) {PCB p = &q->queue[(q->front + i) % MAX_PROCESSES];printf("PID: %d, Arrival Time: %d, Need Time: %d, Used Time: %d, Priority: %d, State: %d\n",p->pid, p->arrival_time, p->need_time, p->used_time, p->priority, p->state);}}void init_processes() {for (int i = 0; i < MAX_PROCESSES; i++) {processes[i].pid = i;processes[i].arrival_time = rand() % 10;processes[i].need_time = rand() % 10 + 1;processes[i].used_time = 0;processes[i].priority = rand() % 3;processes[i].state = 0;}}void schedule() {int time = 0;while (process_count > 0) {for (int i = 0; i < process_count; i++) {PCB p = &processes[i];if (p->arrival_time == time) {enqueue(&ready_queue, p);p->state = 1;}}if (!is_empty(&ready_queue)) {PCB p = dequeue(&ready_queue);p->used_time++;printf("Process %d is running.\n", p->pid);if (p->used_time == p->need_time) {p->state = 2;printf("Process %d is finished.\n", p->pid); }}time++;}}int main() {srand(time(NULL));init_queue(&ready_queue);init_processes();process_count = rand() % MAX_PROCESSES + 1;schedule();print_queue(&ready_queue);return 0;}```五、实验结果与分析1. FIFO调度算法实验结果表明，FIFO调度算法按照进程的到达时间进行调度，可能导致短作业等待时间长，效率较低。

操作系统进程调度实验报告

实验报告课程名称计算机操作系统实验名称进程调度算法模拟专业班级计1103学生姓名贾梦洁指导教师王潇潇实验报告课程名称操作系统原理实验名称实验一进程调度算法模拟姓名贾梦洁学号201107010330专业班级计1103实验日期2014年 4月11日成绩指导教师王潇潇一.实验要求：①进程数不少于5个；②进程调度算法任选；可以用动态优先数加时间片轮转法实现进程调度，每运行一个时间片优先数减3；③用C语言编程；④程序运行时显示进程调度过程。

二.实验内容设计一个简单的进程调度算法，模拟OS中的进程调度过程；三.实验步骤：①设计PCB及其数据结构：进程标识数：ID进程优先数：PRIORITY（优先数越大，优先级越高）进程已占用时间片：CPUTIME，每得到一次调度，值加1；进程还需占用时间片：ALLTIME，每得到一次调度，该值减1，一旦运行完毕，ALLTIME为0）进程队列指针：NEXT，用来将PCB排成队列进程状态：STATE（一般为就绪，可以不用）②设计进程就绪队列及数据结构；③设计进程调度算法，并画出程序流程图；④设计输入数据和输出格式；结构格式：当前正运行的进程：0当前就绪队列：2，1，3，4⑤编程上机，验证结果。

假设调度前，系统中有5个进程，其初始状态如下：ID 0 1 2 3 4PRIORITY 9 38 30 29 0 可否考虑用CPUTIME 0 0 0 0 0 数组或链表ALLTIME 3 2 6 3 4去实现STA TE ready ready ready ready ready①以时间片为单位调度运行；②每次调度ALLTIME不为0，且PRIORITY最大的进程运行一个时间片；③上述进程运行后其优先数减3，再修改其CPUTIME和ALLTIME，重复②，③④直到所有进程的ALLTIME均变为0。

实验源代码：#include<stdio.h>#include<malloc.h>typedef int Status;#define ERROR 0#define OK 1typedef struct PCB{char NAME[10]; //进程名字int PRIO; //进程优先数int ROUNT; //轮转时间片int COUNT; //计数器int NEEDTIME; //需要的CPU时间int CPUTIME; //占用cpu时间char *STATE; //进程状态}ElemPCB;typedef struct QNode{ElemPCB pcb;struct QNode *next;}QNode, *QueuePtr;typedef struct{ //就绪队列QueuePtr RUN; //当前运行进程指针QueuePtr READY; //头指针QueuePtr TAIL; //尾指针}READYQueue;typedef struct{ //完成队列QueuePtr FINISH; //头指针QueuePtr TAIL; //尾指针}FINISHQueue;Status Create(READYQueue &ready);Status Print(READYQueue ready,FINISHQueue finish);Status Printr(READYQueue ready,FINISHQueue finish);Status Fisrt(READYQueue &ready);Status Insert1(READYQueue &ready);Status Insert2(READYQueue &ready);Status Prisch(READYQueue &ready,FINISHQueue &finish);Status Roundsch(READYQueue &ready,FINISHQueue &finish);void main(){char ch;READYQueue ready;FINISHQueue finish;ready.READY=ready.TAIL=(QueuePtr)malloc(sizeof(QNode)); //存储分配ready.RUN=(QueuePtr)malloc(sizeof(QNode));ready.RUN->next=NULL;finish.FINISH=finish.TAIL=(QueuePtr)malloc(sizeof(QNode));Create(ready);//创建后就绪对列中printf("\n就绪对列中初始值：\n");Print(ready,finish);Fisrt(ready);printf("请输入要选择调度的算法(p--优先数调度,r--时间片轮转法):\n");while(1){do{ch=getchar();scanf("%c",&ch);}while(ch!='p' && ch!='r');switch(ch){case 'p'://优先数调度Prisch(ready,finish);break;case 'r'://时间片轮转法Roundsch(ready,finish);break;}}}Status Print(READYQueue ready,FINISHQueue finish){ //打印就绪队列中的进程状态QueuePtr p,q;p=ready.READY;q=finish.FINISH;//运行中的进程if(ready.RUN->next!=NULL){printf("%s",ready.RUN->next->);printf(":%s\t",ready.RUN->next->pcb.STATE);printf("优先数:%d\n",ready.RUN->next->pcb.PRIO);}//就绪队列的进程while(p!=ready.TAIL){printf("%s",p->next->);printf(":%s\t",p->next->pcb.STA TE);printf("优先数:%d\n",p->next->pcb.PRIO);p=p->next;}//完成队列的进程while(q!=finish.TAIL){printf("%s",q->next->);printf(":%s\t",q->next->pcb.STA TE);printf("优先数:%d\n",q->next->pcb.PRIO);q=q->next;}return OK;}Status Printr(READYQueue ready,FINISHQueue finish){ //打印就绪队列中的进程状态QueuePtr p,q;p=ready.READY;q=finish.FINISH;//运行中的进程if(ready.RUN->next!=NULL){printf("%s",ready.RUN->next->);printf(":%s\t",ready.RUN->next->pcb.STATE);printf("剩余时间:%d\n",ready.RUN->next->pcb.NEEDTIME);}//就绪队列的进程while(p!=ready.TAIL){printf("%s",p->next->);printf(":%s\t",p->next->pcb.STA TE);printf("剩余时间:%d\n",p->next->pcb.NEEDTIME);p=p->next;}//完成队列的进程while(q!=finish.TAIL){printf("%s",q->next->);printf(":%s\t",q->next->pcb.STA TE);printf("剩余时间:%d\n",q->next->pcb.NEEDTIME);q=q->next;}return OK;}Status Create(READYQueue &ready){QueuePtr p;int n;printf("请输入进程个数:");scanf("%d",&n);while(i<n){p=(QueuePtr)malloc(sizeof(QNode));printf("输入第%d进程名:",i+1);scanf("%s",p->);printf("输入进程需要的时间:");scanf("%d",&p->pcb.NEEDTIME);printf("输入进程的进程优先数:");scanf("%d",&p->pcb.PRIO);p->pcb.STATE="W";p->pcb.ROUNT=2;p->pcb.COUNT=0;i++;p->next=NULL;ready.TAIL->next=p;ready.TAIL=p;}return OK;}Status Fisrt(READYQueue &ready){if(ready.READY==ready.TAIL)return ERROR;ready.RUN->next=ready.READY->next;ready.RUN->next->pcb.STA TE="RUN"; //修改进程状态if(ready.TAIL==ready.READY->next)ready.READY=ready.TAIL;elseready.READY->next=ready.READY->next->next; //头指针后移printf("\n%s被从就绪队列调度运行\n",ready.RUN->next->);}Status Insert1(READYQueue &ready){int i=0,j=0;QueuePtr p=ready.READY,q;ElemPCB temp;QueuePtr s=(QueuePtr)malloc(sizeof(QNode));s->pcb=ready.RUN->next->pcb;s->next=NULL; //将未完成的进程插入就绪队列ready.TAIL->next=s;ready.TAIL=s;//按优先数从大到小排序for(p;p!=ready.TAIL;p=p->next){for(q=p->next;q!=ready.TAIL;q=q->next){if(p->next->pcb.PRIO < q->next->pcb.PRIO){temp=p->next->pcb;p->next->pcb=q->next->pcb;q->next->pcb=temp;}}}return OK;}Status Insert2(READYQueue &ready){QueuePtr p=ready.RUN->next;if(p->pcb.NEEDTIME > 0){ready.TAIL->next=p; //插入到就绪队列ready.TAIL=p;ready.RUN->next=NULL;}return OK;}Status Prisch(READYQueue &ready,FINISHQueue &finish){int i=0 ;while(ready.RUN->next!=NULL){ready.RUN->next->pcb.CPUTIME++;ready.RUN->next->pcb.NEEDTIME--;ready.RUN->next->pcb.PRIO-=3;if(ready.RUN->next->pcb.NEEDTIME==0){finish.TAIL->next=ready.RUN->next; //插入到完成队列finish.TAIL=ready.RUN->next; //尾指针后移ready.RUN->next->pcb.STA TE="FINISH";ready.RUN->next=NULL;if(ready.READY!=ready.TAIL){Fisrt(ready);}}else if(ready.READY != ready.TAIL && (ready.RUN->next->pcb.PRIO) < (ready.READY->next->pcb.PRIO)){ready.RUN->next->pcb.STA TE="W";printf("%s被调到就绪队列里\n",ready.RUN->next->);Insert1(ready);Fisrt(ready);}i++;printf("\n进程执行第%d个时间片的结果：\n",i);Print(ready,finish);}return OK;}Status Roundsch(READYQueue &ready,FINISHQueue &finish){int i=0;while(ready.RUN->next!=NULL){ready.RUN->next->pcb.CPUTIME++;ready.RUN->next->pcb.NEEDTIME--;ready.RUN->next->pcb.COUNT++;if(ready.RUN->next->pcb.NEEDTIME==0){finish.TAIL->next=ready.RUN->next; //插入到完成队列finish.TAIL=ready.RUN->next; //尾指针后移ready.RUN->next->pcb.STA TE="FINISH";ready.RUN->next=NULL;if(ready.READY!=ready.TAIL){Fisrt(ready);}}else if(ready.RUN->next->pcb.COUNT==ready.RUN->next->pcb.ROUNT){ready.RUN->next->pcb.COUNT=0;if(ready.READY != ready.TAIL){ready.RUN->next->pcb.STATE="W";printf("%s被调到就绪队列里\n",ready.RUN->next->);Insert2(ready);Fisrt(ready);}}i++;printf("\n进程执行第%d个时间片的结果：\n",i);Printr(ready,finish);}return OK;}四.实验运行结果：（中间过程截图略）五．实验总结通过这次实验，对于进程调度算法的知识有了更加深刻的掌握。

实验进程调度源代码

实验进程调度源代码实验2 进程调度（一）目的和要求进程调度是处理机管理的核心内容。

本实验要求用高级语言编写和调试一个简单的进程调度程序。

通过本实验可以加深理解有关进程控制块、进程队列的概念，并体会和了解优先数和时间片轮转调度算法的具体实施方法。

（二）实验内容（1）设计进程控制块PCB结构，分别适用于优先数调度算法和循环轮转调度算法。

PCB结构包括以下信息：进程标识符，进程优先数（或轮转时间片），进程所占用的CPU时间、进程状态，当前队列指针等。

根据调度算法不同，PCB结构的内容可适当做增删。

（2）建立进程就绪队列。

对两种不同算法编制入链子程序。

（3）编制两种进程调度算法：1）优先数调度；2）循环轮转调度。

（三）实验环境用BORLAND C语言（四）范例说明采用C语言编写程序，选用优先数法或简单轮转法对五个进程进行调度，每个进程处于运行（RUN），就绪（READY）和完成（FINISH）三种状态之一，并假定起始状态为就绪状态。

1．数据结构PCB结构如下：NAME 进程标识符PRIO / ROUND 优先数/ 时间片CPUTIME 进程已占用的CPU时间NEEDTIME 进程到完成还需要的CPU时间NEXT 处于同一状态的下一进程的地址STATUS 进程所处的状态“R”进程处于运行状态“W”进程处于就绪状态“F”进程处于完成状态2．程序说明（1）在优先数算法中，进程每执行一次，优先数减3，CPU时间片加1，进程还需要的时间片数减1。

在轮转法中，采用固定时间片，时间片数为2，进程每执行一次，CPU时间片数加2，进程还需要的时间片数减2，并排在就绪队列的队尾。

（2）程序结构说明如下：①INSERT1：把未完成且优先数小于别的进程的进程PCB按进程优先数的顺序插入到就绪队列中。

②INSERT2：轮转法中使用的过程，将执行一个单位时间片数（为2）且还未完成的进程的PCB插入到就绪队列队尾。

③FIRSTIN：将就绪队列中的第一个进程投入运行。

操作系统实验报告进程调度

五邑大学实验报告操作系统课程2016~2017年度第1学期实验题目：进程调度院系：计算机学院班级：140801学号：3114002472姓名：黄凯鑫任课教师：白明成绩评定：实验二题目：进程调度完成日期：2016 年 12 月 11 日1、实验目的（1 ）设计一个有n个进程工行的进程调度程序。

每个进程由一个进程控制块（ PCB）表示。

进程控制块通常应包含下述信息：进程名、进程优先数、进程需要运行的时间、占用 CPU 的时间以及进程的状态等，且可按调度算法的不同而增删。

（2）调度程序应包含 2～3 种不同的调度算法，运行时可任意选一种，以利于各种算法的分析比较。

（3）系统应能显示或打印各进程状态和参数的变化情况，便于观察诸进程的调度过程2、实验内容（1）编制和调试示例给出的进程调度程序，并使其投入运行。

（2）自行设计或改写一个进程调度程序，在相应机器上调试和运行该程序，其功能应该不亚于示例。

（ 3）直观地评测各种调度算法的性能。

3、算法设计算法：(1)优先数法。

进程就绪链按优先数大小从高到低排列，链首进程首先投入运行。

每过一个时间片，运行进程所需运行的时间片数减1，说明它已运行了一个时间片，优先数也减3，理由是该进程如果在一个时间片中完成不了，优先级应该降低一级。

接着比较现行进程和就绪链链首进程的优先数，如果仍是现行进程高或者相同，就让现行进程继续进行，否则，调度就绪链链首进程投入运行。

原运行进程再按其优先数大小插入就绪链，且改变它们对应的进程状态，直至所有进程都运行完各自的时间片数。

(2)简单轮转法。

进程就绪链按各进程进入的先后次序排列，进程每次占用处理机的轮转时间按其重要程度登入进程控制块中的轮转时间片数记录项（相当于优先数法的优先数记录项位置）。

每过一个时间片，运行进程占用处理机的时间片数加 1 ，然后比较占用处理机的时间片数是否与该进程的轮转时间片数相等，若相等说明已到达轮转时间，应将现运行进程排到就绪链末尾，调度链首进程占用处理机，且改变它们的进程状态，直至所有进程完成各自的时间片。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

用循环来实现对每个进程的进程名、进程优先数（随机分配）以及所需时间的录入。将进程队列存放到就绪队列等待执行。
（2）优先数调度算法模块
从优先级最高（就绪队列的第一个进程）的开始执行，每执行一次优先数减1，并重新放入就绪队列进行排序，对排序完的继续运行直到所有进程都结束。
（3）FCFS创建PCB模块
对N个进程的信息进行输入：进程名、到达时间、需要时间等。每输入一个进程，按进程的到达时间进行排序，记下前驱和后继的方法。
三、总体设计
进程是程序在处理机上的执行过程。进程存在的标识是进程控制块（PCB），所谓系统创建一个进程，就是由系统为某个程序设置一个PCB，用于对该进程进行控制和管理。进程任务完成，由系统收回其PCB，该进程便消亡。每个进程可有三个状态：运行状态、就绪状态和完成状态。因此设计三个链队列，finish为完成队列的头指针，wait为就绪队列的头指针。因为每一时刻，CPU只能运行一个进程，所以运行队列只有一个run指针指向当前运行的进程。考虑到处理的方便，将它们设为全局变量。
成绩
课程设计报告
题目进程调度程序设计
课程名称操作系统课程设计
院部名称计算机工程学院
专业计算机科学与技术
班级13计算机科学与技术(单)(1)
学生姓名周敏健
学号1305201013
课程设计地点A104
课程设计学时20学时
指导教师何健
金陵科技学院教务处制
课程设计课题
进程调度程序设计
摘要
在多道系统中，对批处理作业需要进行作业调度。作业调度是在资源满足的条件下，将处于就绪状态的作业调入内存，同时生成与作业相对应的进程，并未这些进程提供所需要的资源。进程调度需要根据进程控制块（PCB）中的信息，检查系统是否满足进程的资源需求。只有在满足进程的资源需求的情况下，系统才能进行进程调度。下面是几种常见的作业调度算法：先来先服务（FCFS）、优先算法、轮换算法、短作业优先算法以及最高响应比优先法等，本文将对前两种算法进行详细的介绍。
（2）先来先服务调度算法
先Hale Waihona Puke 先服务调度算法是按照进程进入就绪队列的先后顺序调度并分配处理机执行。先来先服务算法是一种不可抢占的算法，先进入就绪队列的进程，先被处理机运行，一旦一个进程占有了处理机，它就一直运行下去，直到该进程完成工作或者因为等待某种事件而不能继续运行时才释放处理机。
五、测试、调试过程
4）每个进程的状态可以是就绪W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。
5）就绪进程获得CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。
界面
优先数算法输入
优先数算法输出
FCFS算法输入
FCFS算法输出
遇到的问题：
在设计程序时，在算法上面出现了一些错误，优先数不是由大到小排序，而是应该这样理解，当进程执行一个时间片时，优先数减一（使用CPU的时间变少，反而优先级高），因此，优先级高的优先数应该是比较小的，而不是优先数大的优先级大。在程序调试时，链表发生了错误，该内存不可写或者就是程序直接结束，但最终结果不是我想要的，经过一番折腾，最后发现，头指针和头结点混淆，有些地方没有给指针分配内存，语句的先后顺序不正确，以及没有考虑到链表最后没有设置结束标志。
总体结构框架图：
四、详细设计
（1）优先数调度算法
优先调度算法要为每一个进程设一个优先数，它总是把处理机给就绪队列中具有最高优先权的进程。常用的算法有静态优先权法和动态优先权法。本程序采用了动态优先权法，使进程的优先权随时间而改变。初始的进程优先数取决于进程运行所需的时间，时间大，则优先数低，所以采取了将进程优先数定位最大的那个进程，随着进程的运行优先数进行调整，每次运行时都是从就绪队列中选取优先数最大的进程运行，所以将就绪队列按照优先数的大小从高到低排序，这样，每次取队头进程即可。
2、要求
1）进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。
2）每个进程有一个进程控制块（PCB）表示。进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
3）进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。进程的到达时间为进程输入的时间。进程的运行时间以时间片为单位进行计算。
6）每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。
7）重复以上过程，直到所要进程都完成为止。
二、系统需求分析
编写一个模拟进程调度的程序，将每个进程抽象成一个进程控制块PCB，PCB用一个结构体描述。
采用两种不同的调度算法来实现功能，主要有如下几大功能模块组成。
（1）创建优先数PCB模块
（4）FCFS调度算法模块
当系统时间与第一个进程到达时间一致时，将进程状态置为Run，直到这个进程执行完，再判断下个进程的到达时间，若系统时间大于下个进程的到达时间，即上个进程的结束时间就是下个进程的开始时间，反之就等待系统时间。进程结束后放入完成队列。
（5）主函数及菜单显示
由主菜单进入显示界面，进行算法选择。
关键词：进程调度，优先级，FCFS，PCB，作业，资源
1、目的
进程调度是处理机管理的核心内容。本设计要求用C语言编写和调试一个简单的进程调度程序。通过设计本可以加深理解有关进程控制块、进程队列的概念，并体会和了解最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法的具体实施办法。
六、结论与体会
做这个程序我断断续续的算下来应该总共用了2天，主要是花时间在观察别人的算法读别人的程序，然后才开始写自己的程序，期间参考了前人的程序并进行了改善和加工，这让我对进程调度的理解再次加深了，这是在平常学习的基础上，与程序相结合的过程，让我再次感受到编程给我们带来的无穷魅力，只要自己有兴趣，其实编程也是一件有趣的事，为了达到一定的要求，我们必须多次尝试用不同的方法去实现它，比如，进程调度有先来先服务算法，对于这个算法，可以用数组实现，也可以用链表实现，但是到底哪个更好哪个更灵活呢，相信学过C语言的人都知道肯定是用链表实现最好了。这次设计还是有一些不足之处的，比如在算法和运行效率上还是有些欠缺的，需要进一步去改善程序代码，提高效率，减少冗余和错误，让使用者更清晰的观察和理解进程调度。