操作系统实验之进程管理

目录

一、实验目的

二、实验内容

三、实验思路

四、主要数据结构

五、实验流程图

 六、实验代码

七、运行结果：

 总结：

---

一、实验目的

通过本次实验，加深对进程概念的理解，进一步掌握进程状态的转变及进程调度算法

二、实验内容

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;
	}
}

七、运行结果：

 总结：

以上是进程管理的的全部实现，仅以本人理解实验，如有不足，请批评指正。