操作系统实验之进程管理
目录
一、实验目的
二、实验内容
三、实验思路
四、主要数据结构
五、实验流程图
六、实验代码
七、运行结果：
总结：
一、实验目的
通过本次实验，加深对进程概念的理解，进一步掌握进程状态的转变及进程调度算法
二、实验内容
1. 设计调试运行“时间片轮转”调度算法，给出运行结果。
2. 采用“时间片轮转”调度算法对5个进程进行调度，每个进程有一个进程控制块PCB，进程控制块可包含以下信息：进程名、到达时间、需要运行的时间（以时间片为单位）、已用cpu时间（以时间片为单位）、进程状态等等。
3. 每个进程的状态可以是就绪W、运行R、或阻塞B三种状态之一。每进行一次调度就打印一次运行进程、就绪队列、以及各进程PCB。重复以上过程，直到所有进程都完成。
三、实验思路
“时间片轮转”调度算法：系统把所有进程按照状态通过PCB使其进去相应的队列。
在就绪队列里按先入先出的原则排成一个队列。新来的进程加到就绪队列末尾。每当执行进程调度时，进程调度程序总是选出就绪队列的队首进程，让它在CPU上运行一个时间片的时间。当进程用完分给它的时间片后，系统的计时器发出时钟中断，调度程序便停止该进程的运行，把它放入就绪队列的末尾；然后，把CPU分给就绪队列的队首进程，同样也让它运行一个时间片，如此往复。
在阻塞队列里由于进程阻塞，所有未能获得CPU的使用权，当满足一定的条件时，进程状态改变，从阻塞队列中退出，进入就绪队列中等待PCB的调度，如此往复。
本实验模拟操作系统“时间片轮转”的进程调度算法，采用以键盘输入的方式获取时间片和初始状态各进程的PCB，对进程的进行调度。每个进程创建一个进程控制块，记录进程的基本信息。定义PCB类和队列类，利用队列先进先出的特点，实现进程在就绪队列、运行队列、阻塞队列之间的切换，同时状态进行改变。
四、主要数据结构
PCB：进程控制块，记录进程名、进程状态(就绪、运行、阻塞)、已用CPU时间、到达CPU时间、需要CPU总时间等基本信息。
队列：特点是先进先出，符合就绪、运行、阻塞队列的需求。从队尾入队，从队首出队。
五、实验流程图
六、实验代码
//主程序：
import java.util.Scanner;
public class RR {
String name; // 进程名
double AT; // 到达时间
double RT; // 需要运行时间
public RR() {
}
public RR(String name, double AT, double RT) {
this.name = name;
this.AT = AT;
this.RT = RT;
}
public void Way() {
String a;
double b, c;
char d;
int i, j = 0;
int m = 0;
int input; // 进程数
int time;// 用于后面计算是否运行够一个时间片
int number = 0;// 记录已用时间片个数
int CPUTIME; // 设置时间片为5
int counter = 1;// 每过counter个时间片就唤醒阻塞队首进程****************
Queue Blocked = new Queue(); // 阻塞队列
Queue Ready = new Queue(); // 就绪队列
Scanner sc = new Scanner(System.in);
System.out.println("请输入进程数");
input = sc.nextInt();
System.out.println("请输入时间片大小");
CPUTIME = sc.nextInt();
PCB[] pcb = new PCB[input];
System.out.println("请依次输入进程名、到达时间、需要运行时间、进程状态");
for (i = 0; i < input; i++) {
a = sc.next();
b = sc.nextDouble();
c = sc.nextDouble();
d = sc.next().charAt(0);
pcb[i] = new PCB(a, b, c, d);
}
// 排序
PCB t = new PCB();// 中间变量，用于排序
for (i = 0; i < input - 1; i++) { // 排列，先到达的排在前面
for (j = 0; j < input - 1 - i; j++) {
if (pcb[j].AT > pcb[j + 1].AT) {
t = pcb[j];
pcb[j] = pcb[j + 1];
pcb[j + 1] = t;
}
}
}
System.out.println("进程名 到达时间 需要运行时间 进程状态"); // 输出排序后的进程
for (i = 0; i < input; i++) {
System.out.print(" " + pcb[i].name + " ");
System.out.print(pcb[i].AT + " ");
System.out.print(pcb[i].RT + " ");
System.out.println(pcb[i].State);
}
double nowtime = pcb[0].AT; // 现在的时间为第一个进程到达的时间
// 分为就绪队列和阻塞队列 分别入队
for (i = 0; i < input; i++) {
if (pcb[i].State == 'B') {// 处于阻塞状态的进程
Blocked.come(i);
} else {// 处于就绪状态的进程
Ready.come(i);
}
}
// 初始结束
while (Blocked.isexit() == 1 || Ready.isexit() == 1) {// Blocked队列不空或Ready队列不空
m = 0;// 用来控制一个进程进入
// && number % counter == 0
for (i = Blocked.F; i < Blocked.L; i++) { // 如果阻塞队列里的进程的等待条件满足了，就进入就绪队列
if (pcb[Blocked.elements[i]].AT <= nowtime && number % counter == 0) {// 这个时间它已经到达并且现在时间片个数是counter的倍数
if (m < 1) {// 每次只有队首可以进入Ready队列
pcb[Blocked.elements[Blocked.F]].State = 'W';
Ready.come(Blocked.elements[i]);// 进入ready
Blocked.out();
m++;
}
}
}
while (Ready.isexit() == 1) {// ready队列不空,就绪队列首进程开始执行
time = (int) pcb[Ready.elements[Ready.F]].RT;// 用于保留当前进程的需要运行时间
pcb[Ready.elements[Ready.F]].RT = pcb[Ready.elements[Ready.F]].RT - CPUTIME; // 一个时间片结束后，进程需要的时间减少
pcb[Ready.elements[Ready.F]].CPUT++; // 已占用CPU时间+1
pcb[Ready.elements[Ready.F]].State = 'R'; // 状态先置为运行
System.out.println("----------------------------------------");
System.out.println("现在的时间为：" + nowtime);
System.out.println("就绪队列如下：");
for (int k = Ready.F; k < Ready.L; k++) {
System.out.print(pcb[Ready.elements[k]].name + ' ');
}
System.out.println();
System.out.println("执行进程为" + pcb[Ready.elements[Ready.F]].name);
nowtime = nowtime + CPUTIME;
number++;
if (pcb[Ready.elements[Ready.F]].RT < 0) {
pcb[Ready.elements[Ready.F]].RT = 0;
}
System.out.println("进程名 到达时间 需要运行时间 已占用CPU时间 进程状态"); // 输出进程名、到达时间、需要运行时间、 已占用CPU时间、进程状态
for (i = 0; i < input; i++) {
System.out.print(" " + pcb[i].name + " ");
System.out.print(pcb[i].AT + " ");
System.out.print(pcb[i].RT + " ");
System.out.print(pcb[i].CPUT + " ");
System.out.println(pcb[i].State);
}
m = 0;
for (i = Blocked.F; i < Blocked.L; i++) {
if (pcb[Blocked.elements[i]].AT <= nowtime &&number%counter==0) {// 这个时间它已经到达并且现在时间片个数是counter的倍数
if (m < 1) {// 每次只有队首可以进入Ready队列
pcb[Blocked.elements[Blocked.F]].State = 'W';
Ready.come(Blocked.elements[i]);// 进入ready
Blocked.out();
m++;
}
}
}
if (pcb[Ready.elements[Ready.F]].RT > 0) { // 如果进程需要的时间大于0，则进入就绪队列
Ready.come(Ready.elements[Ready.F]); // 否则把进程需要的时间置为0、把状态置为
} else {
pcb[Ready.elements[Ready.F]].State = ' ';
Ready.out();
}
if (pcb[Ready.elements[Ready.F]].State == 'R') {// 将 CPU 分配给新的队首进程。
pcb[Ready.elements[Ready.F]].State = 'W';
Ready.out();
}
if (time - CPUTIME < 0) {// 时间片未用完但正在运行的进程已经完成
nowtime = nowtime + time - CPUTIME;
}
System.out.println("结束时间为：" + nowtime);
// 每过counter个时间片 处于阻塞队列队首的进程被唤醒 也就是状态变为W 且退出阻塞队列 进入就绪队列
} // 内层while结束
System.out.println("所有进程已完成总共耗时"+nowtime);
System.out.println();
nowtime = nowtime + CPUTIME;
number++;// 时间片个数加一
} // 外层while结束
sc.close();
}
public static void main(String[] args) {
System.out.println("*************************************************");
RR t = new RR();
t.Way();
}
}
//RR
import java.util.Scanner;
public class RR {
String name; // 进程名
double AT; // 到达时间
double RT; // 需要运行时间
public RR() {
}
public RR(String name, double AT, double RT) {
this.name = name;
this.AT = AT;
this.RT = RT;
}
public void Way() {
String a;
double b, c;
char d;
int i, j = 0;
int m = 0;
int input; // 进程数
int time;// 用于后面计算是否运行够一个时间片
int number = 0;// 记录已用时间片个数
int CPUTIME; // 设置时间片为5
int counter = 1;// 每过counter个时间片就唤醒阻塞队首进程****************
Queue Blocked = new Queue(); // 阻塞队列
Queue Ready = new Queue(); // 就绪队列
Scanner sc = new Scanner(System.in);
System.out.println("请输入进程数");
input = sc.nextInt();
System.out.println("请输入时间片大小");
CPUTIME = sc.nextInt();
PCB[] pcb = new PCB[input];
System.out.println("请依次输入进程名、到达时间、需要运行时间、进程状态");
for (i = 0; i < input; i++) {
a = sc.next();
b = sc.nextDouble();
c = sc.nextDouble();
d = sc.next().charAt(0);
pcb[i] = new PCB(a, b, c, d);
}
// 排序
PCB t = new PCB();// 中间变量，用于排序
for (i = 0; i < input - 1; i++) { // 排列，先到达的排在前面
for (j = 0; j < input - 1 - i; j++) {
if (pcb[j].AT > pcb[j + 1].AT) {
t = pcb[j];
pcb[j] = pcb[j + 1];
pcb[j + 1] = t;
}
}
}
System.out.println("进程名 到达时间 需要运行时间 进程状态"); // 输出排序后的进程
for (i = 0; i < input; i++) {
System.out.print(" " + pcb[i].name + " ");
System.out.print(pcb[i].AT + " ");
System.out.print(pcb[i].RT + " ");
System.out.println(pcb[i].State);
}
double nowtime = pcb[0].AT; // 现在的时间为第一个进程到达的时间
// 分为就绪队列和阻塞队列 分别入队
for (i = 0; i < input; i++) {
if (pcb[i].State == 'B') {// 处于阻塞状态的进程
Blocked.come(i);
} else {// 处于就绪状态的进程
Ready.come(i);
}
}
// 初始结束
while (Blocked.isexit() == 1 || Ready.isexit() == 1) {// Blocked队列不空或Ready队列不空
while (Ready.isexit() == 1) {// ready队列不空,就绪队列首进程开始执行
time = (int) pcb[Ready.elements[Ready.F]].RT;// 用于保留当前进程的需要运行时间
pcb[Ready.elements[Ready.F]].RT = pcb[Ready.elements[Ready.F]].RT - CPUTIME; // 一个时间片结束后，进程需要的时间减少
pcb[Ready.elements[Ready.F]].CPUT++; // 已占用CPU时间+1
pcb[Ready.elements[Ready.F]].State = 'R'; // 状态先置为运行
System.out.println("----------------------------------------");
System.out.println("现在的时间为：" + nowtime);
System.out.println("就绪队列如下：");
for (int k = Ready.F; k < Ready.L; k++) {
System.out.print(pcb[Ready.elements[k]].name + ' ');
}
System.out.println();
System.out.println("执行进程为" + pcb[Ready.elements[Ready.F]].name);
nowtime = nowtime + CPUTIME;
number++;
System.out.println("进程名 到达时间 需要运行时间 已占用CPU时间 进程状态"); // 输出进程名、到达时间、需要运行时间、 已占用CPU时间、进程状态
for (i = 0; i < input; i++) {
System.out.print(" " + pcb[i].name + " ");
System.out.print(pcb[i].AT + " ");
System.out.print(pcb[i].RT + " ");
System.out.print(pcb[i].CPUT + " ");
System.out.println(pcb[i].State);
}
if (pcb[Ready.elements[Ready.F]].RT > 0) { // 如果进程需要的时间大于0，则进入就绪队列
Ready.come(Ready.elements[Ready.F]); // 否则把进程需要的时间置为0、把状态置为
} else {
pcb[Ready.elements[Ready.F]].RT = 0;
pcb[Ready.elements[Ready.F]].State = ' ';
Ready.out();
}
if (pcb[Ready.elements[Ready.F]].State == 'R') {// 将 CPU 分配给新的队首进程。
pcb[Ready.elements[Ready.F]].State = 'W';
Ready.out();
}
if (time - CPUTIME < 0) {// 时间片未用完但正在运行的进程已经完成
nowtime = nowtime + time - CPUTIME;
}
System.out.println("结束时间为：" + nowtime);
// 每过counter个时间片 处于阻塞队列队首的进程被唤醒 也就是状态变为W 且退出阻塞队列 进入就绪队列
m = 0;
for (i = Blocked.F; i < Blocked.L; i++) {
if (pcb[Blocked.elements[i]].AT <= nowtime &&number%counter==0) {// 这个时间它已经到达并且现在时间片个数是counter的倍数
if (m < 1) {// 每次只有队首可以进入Ready队列
pcb[Blocked.elements[Blocked.F]].State = 'W';
Ready.come(Blocked.elements[i]);// 进入ready
Blocked.out();
m++;
}
}
}
} // 内层while结束
System.out.println("所有进程已完成总共耗时"+nowtime+"cc");
System.out.println();
nowtime = nowtime + CPUTIME;
number++;// 时间片个数加一
m = 0;// 用来控制一个进程进入
// && number % counter == 0
for (i = Blocked.F; i < Blocked.L; i++) { // 如果阻塞队列里的进程的等待条件满足了，就进入就绪队列
if (pcb[Blocked.elements[i]].AT <= nowtime && number % counter == 0) {// 这个时间它已经到达并且现在时间片个数是counter的倍数
if (m < 1) {// 每次只有队首可以进入Ready队列
pcb[Blocked.elements[Blocked.F]].State = 'W';
Ready.come(Blocked.elements[i]);// 进入ready
Blocked.out();
m++;
}
}
}
} // 外层while结束
sc.close();
}
public static void main(String[] args) {
System.out.println("*************************************************");
RR t = new RR();
t.Way();
}
}
//PCB:
public class PCB { // 进程的pcb
String name; // 进程名
double AT; // 到达时间
double RT; // 需要运行时间
int CPUT = 0; // 已用CPU时间
char State; // 进程状态
PCB() {
}
PCB(String name, double AT, double RT, char State) {
this.name = name;
this.AT = AT;
this.RT = RT;
this.State = State;
}
}
//队列节点：
public class Queue { // 队列
int elements[] = new int[1000];
int F = 0;// 队头
int L = 0;// 队尾
void come(int num) {// 入队
if (L >= 999)
System.out.println("队满");
elements[L] = num;
L++;
}
void out() {// 出队
if (F > L)
System.out.println("队空");
F++;
}
int isexit() {// 判断空不空
if (L > F)// 不空
return 1;
else// 空
return 0;
}
}七、运行结果：
总结：
以上是进程管理的的全部实现，仅以本人理解实验，如有不足，请批评指正。