操作系统实验之进程管理

已于 2023-10-28 15:41:04 修改
阅读量3.3k 收藏 71
点赞数 4
分类专栏： 操作系统 文章标签： java
于 2023-05-27 22:48:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64377514/article/details/130906964
版权

目录

一、实验目的

二、实验内容

三、实验思路

四、主要数据结构

五、实验流程图

 六、实验代码

七、运行结果：

 总结：

一、实验目的

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

二、实验内容

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

七、运行结果：

 总结：

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

十亿少男的梦421
关注
专栏目录
第六章操作系统实验之进程管理
Junds0的博客
11-30 1184
可以使用 Popen 来创建进程，并与进程进行复杂的交互。此外，psutil中还定义了Process类，以进程ID为参数，可以实例化一个Process对象，通过Process类提供的各种方法，可以查看该ID对应的进程的各中信息。利用该id，可以创建psutil模块的Process对象，从而使用第一关的技术，查看新创建的进程的信息。通过Python编写程序，利用subprocess库中的 Popen 启动 Python 执行 1.py 程序，获取该进程的进程信息，并返回该进程信息的列表。
操作系统实验报告（进程管理）
12-15
操作系统实验报告——进程管理 本实验旨在通过C语言编程实现对多个进程的调度，以便深入理解和体验进程管理的核心概念。实验主要包括三个部分：先来先服务（FCFS）、时间片轮转（RR）以及动态优先级调度算法。下面...
【操作系统】实验二 进程控制实验
AGATHA_66的博客
01-11 2249
本人一直想找时间系统整理一下之前做过的一些实验，便于后续用到的时候可以尽快的使用，po出来也便于大家交流学习，有问题欢迎交流指正，与诸君共勉！操作系统实验二，进程控制。
操作系统实验实验进程管理
06-19
实验二 进程管理   Windows所创建的每个进程都从调用CreateProcess() API函数开始，该函数的任务是在对象管理器子系统内初始化进程对象。每一进程都以调用ExitProcess() 或TerminateProcess() API函数终止。通常应用程序的框架负责调用 ExitProcess() 函数。对于C++ 运行库来说，这一调用发生在应用程序的main() 函数返回之后。 1. 创建进程 CreateProcess() 调用的核心参数是可执行文件运行时的文件名及其命令行。表 2-1详细地列出了每个参数的类型和名称。   表2-1 CreateProcess() 函数的参数 参数名称 使用目的 LPCTSTR lpApplivationName 全部或部分地指明包括可执行代码的EXE文件的文件名 LPCTSTR lpCommandLine 向可执行文件发送的参数 LPSECURIITY_ATTRIBUTES lpProcessAttributes 返回进程句柄的安全属性。主要指明这一句柄是否应该由其他子进程所继承 LPSECURIITY_ATTRIBUTES lpThreadAttributes 返回进程的主线程的句柄的安全属性 BOOL bInheritHandle 一种标志，告诉系统允许新进程继承创建者进程的句柄 DWORD dwCreationFlage 特殊的创建标志 (如CREATE_SUSPENDED) 的位标记 LPVOID lpEnvironment 向新进程发送的一套环境变量；如为null值则发送调用者环境 LPCTSTR lpCurrentDirectory 新进程的启动目录 STARTUPINFO lpStartupInfo STARTUPINFO结构，包括新进程的输入和输出配置的详情 LPPROCESS_INFORMATION lpProcessInformation 调用的结果块；发送新应用程序的进程和主线程的句柄和ID   可以指定第一个参数，即应用程序的名称，其中包括相对于当前进程的当前目录的全路径或者利用搜索方法找到的路径；lpCommandLine参数允许调用者向新应用程序发送数据；接下来的三个参数与进程和它的主线程以及返回的指向该对象的句柄的安全性有关。 然后是标志参数，用以在dwCreationFlags参数中指明系统应该给予新进程什么行为。经常使用的标志是CREATE_SUSPNDED，告诉主线程立刻暂停。当准备好时，应该使用ResumeThread() API来启动进程。另一个常用的标志是CREATE_NEW_CONSOLE，告诉新进程启动自己的控制台窗口，而不是利用父窗口。这一参数还允许设置进程的优先级，用以向系统指明，相对于系统中所有其他的活动进程来说，给此进程多少CPU时间。 接着是CreateProcess() 函数调用所需要的三个通常使用缺省值的参数。第一个参数是lpEnvironment参数，指明为新进程提供的环境；第二个参数是lpCurrentDirectory，可用于向主创进程发送与缺省目录不同的新进程使用的特殊的当前目录；第三个参数是STARTUPINFO数据结构所必需的，用于在必要时指明新应用程序的主窗口的外观。 CreateProcess() 的最后一个参数是用于新进程对象及其主线程的句柄和ID的返回值缓冲区。以PROCESS_INFORMATION结构中返回的句柄调用CloseHandle() API函数是重要的，因为如果不将这些句柄关闭的话，有可能危及主创进程终止之前的任何未释放的资源。 2. 正在运行的进程 如果一个进程拥有至少一个执行线程，则为正在系统中运行的进程。通常，这种进程使用主线程来指示它的存在。当主线程结束时，调用ExitProcess() API函数，通知系统终止它所拥有的所有正在运行、准备运行或正在挂起的其他线程。当进程正在运行时，可以查看它的许多特性，其中少数特性也允许加以修改。 首先可查看的进程特性是系统进程标识符 (PID) ，可利用GetCurrentProcessId() API函数来查看，与GetCurrentProcess() 相似，对该函数的调用不能失败，但返回的PID在整个系统中都可使用。其他的可显示当前进程信息的API函数还有GetStartupInfo()和GetProcessShutdownParameters() ，可给出进程存活期内的配置详情。 通常，一个进程需要它的运行期环境的信息。例如API函数GetModuleFileName() 和GetCommandLine() ，可以给出用在CreateProcess() 中的参数以启动应用程序。在创建应用程序时可使用的另一个
操作系统：实验一进程控制实验
最新发布
OraOla的博客
08-30 1032
通过本次实验，我学到了以下几点：学习了如何使用fork()函数创建子进程，以及父子进程之间的关系。理解了使用wait()和waitpid()函数等待子进程结束，并获取子进程的退出状态。掌握了使用execl()函数在子进程中执行外部命令。加深了对进程间通信和进程控制的理解，例如父进程等待子进程退出的过程。熟悉了在C语言中使用系统调用来实现基本的shell解释器功能。总的来说，通过实验，我加深了对进程管理、进程通信和操作系统底层的理解，并且了解了基本的Linux系统。
操作系统的进程管理（c语言模拟）
热门推荐
best_fiends_zxh的博客
10-12 1万+
今天就更一下，模拟进程管理程序。 #include #include #include #include //#define NULL 0 int shumu=0; //进程的内容结构体 struct node { char a[20]; //int a; // char ch; }; typedef struct node Node; //进程PCB结构体 struc
操作系统（实验1进程管理）
09-20
1.基本系统进程 　　Csrss.exe：这是子系统服务器进程，负责控制Windows创建或删除线程以及16位的虚拟DOS环境。 　　System Idle Process：这个进程是作为单线程运行在每个处理器上，并在系统不处理其它线程的时候分派处理器的时间。 　　Smss.exe：这是一个会话管理子系统，负责启动用户会话。 　　Services.exe：系统服务的管理工具。 　　Lsass.exe：本地的安全授权服务。 　　Explorer.exe：资源管理器。 　　Spoolsv.exe：管理缓冲区中的打印和传真作业。 　　Svchost.exe：这个进程要着重说明一下，有不少朋友都有这种错觉：若是在“任务管理器”中看到多个Svchost.exe在运行，就觉得是有病毒了。其实并不一定，系统启动的时候，Svchost.exe将检查注册表中的位置来创建需要加载的服务列表，如果多个Svchost.exe同时运行，则表明当前有多组服务处于活动状态；多个DLL文件正在调用它。 　　至于其它一些附加进程，大多为系统服务，是可以酌情结束运行的。由于其数量众多，我们在此也不便于一一列举。 　　在系统资源紧张的情况下，我们可以选择结束一些附加进程，以增加资源，起到优化系统的作用。在排除基本系统及附加进程后，新增的陌生进程就值得被大家怀疑了。 更多内容请看Windows操作系统安装、系统优化大全、系统安全设置专题，或进入讨论组讨论。
操作系统-进程管理实验
12-01
关于操作系统模拟进程管理的实验，包括创建、阻塞、唤醒原语等，以及内存的分配与回收。
操作系统进程管理实验报告
07-03
（1）进程的软中断通信 #include #include #include #include int wait_flag; void stop(); main( ) { int pid1, pid2; // 定义两个进程号变量 signal(2,stop); // 或者 signal (14,stop); while((pid1 = fork( )) == -1); // 若创建子进程1不成功,则空循环 if(pid1 > 0) { // 子进程创建成功,pid1为进程号 while((pid2 = fork( )) == -1); // 创建子进程2 if(pid2 > 0) { wait_flag = 1; //sleep(1); // 父进程等待5秒 kill(pid1,SIGUSR1); // 杀死进程1 kill(pid2,SIGUSR2); // 杀死进程2 wait(0); wait(0); printf("\n Parent process is killed !!\n"); exit(0); // 父进程结束 } else { wait_flag = 1; signal(SIGUSR2,stop); // 等待进程2被杀死的中断号17 printf("\n Child process 2 is killed by parent !!\n"); exit(0); } } else { wait_flag = 1; signal(SIGUSR1,stop); // 等待进程1被杀死的中断号16 printf("\n Child process 1 is killed by parent !!\n"); exit(0); } } void stop() { wait_flag = 0; } （2）进程的管道通信 #include #include #include int pid1,pid2; // 定义两个进程变量 main( ) { int fd[2]; char OutPipe[100],InPipe[100]; // 定义两个字符数组 pipe(fd); // 创建管道 while((pid1 = fork( )) == -1); // 如果进程1创建不成功,则空循环 if(pid1 == 0) { lockf(fd[1],1,0); // 锁定管道 sprintf(OutPipe,"\n Child process 1 is sending message!\n"); write(fd[1],OutPipe,50); // 向管道写入数据 sleep(5); // 等待读进程读出数据 lockf(fd[1],0,0); // 解除管道的锁定 exit(0); // 结束进程1 } else { while((pid2 = fork()) == -1); // 若进程2创建不成功,则空循环 if(pid2 == 0) { lockf(fd[1],1,0); sprintf(OutPipe,"\n Child process 2 is sending message!\n"); write(fd[1],OutPipe,50); sleep(5); lockf(fd[1],0,0); exit(0); } else { wait(0); // 等待子进程1 结束 read(fd[0],InPipe,50); // 从管道中读出数据 printf("%s\n",InPipe); // 显示读出的数据 wait(0); // 等待子进程2 结束 read(fd[0],InPipe,50); printf("%s\n",InPipe); exit(0); // 父进程结束 } } }
操作系统实验之进程管理（java实现）
11-29
在这个操作系统实验中，我们将聚焦于进程管理，这是一个至关重要的概念，因为它关乎到系统如何有效地调度和执行多个程序。Java作为一种多平台支持的编程语言，被选中来实现这个实验，这展示了其在系统级编程中的应用...
进程管理实验（操作系统）
11-28
（1） 进程的创建编写一段程序，使用系统调用fork( )创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示字符“a”；子进程分别显示字符“b”和字符“c”。试观察记录屏幕上的显示结果，并分析原因。（2） 进程的控制修改已编写的程序，将每个进程输出一个字符改为每个进程输出一句话，在观察程序执行时屏幕上出现的现象，并分析原因。（3） 编制一段程序，使其实现进程的软中断通信。要求：使用系统调用fork( )创建两个子进程，再用系统调用signal( )让父进程捕捉键盘上来的中断信号（即按Del键）；当捕捉到中断信号后，父进程调用系统调用kill( )向两个子进程发出信号，子进程捕捉到信号后分别输出下列信息后终止： Child process 1 is killed by parent! Child process 2 is killed by parent! 父进程等待两个子进程终止后，输出如下的信息后终止： Parent process is killed! 在上面的程序中增加语句signal(SIGINT, SIG_IGN)和 signal(SIGQUIT, SIG_IGN)，观察执行结果，并分析原因。（4） 进程的管道通信编制一段程序，实现进程的管道通信。使用系统调用pipe( )建立一条管道线；两个进程P1和P2分别向管道各写一句话： Child 1 is sending a message! Child 2 is sending a message! 而父进程则从管道中读出来自于两个子进程的信息，显示在屏幕上。要求父进程先接收子进程P1发来的消息，然后再接收子进程P2发来的消息。
操作系统进程控制实验代码（c语言）
05-17
用C语言编程模拟进程管理，至少要有：创建新的进程；查看运行进程；换出某个进程；杀死运行进程以及进程之间通信等功能。 PCB结构通常包括以下信息：进程名，进程优先数，轮转时间片，进程所占用的CPU时间，进程的状态，当前队列指针等。可根据实验的不同，PCB结构的内容可以作适当的增删。
进程管理实验
10-26
电子科技大学操作系统进程管理过程模拟 基于python编写，有问题csdn交流。
操作系统进程管理实验
04-09
操作系统进程管理实验
操作系统-进程管理实验（1）
张毅轩的博客
01-03 4519
实验一  进程管理 一、实验目的 加强对进程概念的理解。 二、实验内容 创建新的进程；查看运行进程；中止运行进程等功能。 三、实验环境 Windows7 系统 TC 3.0或者VC++6.0 四、实验提示 PCB结构通常包括以下信息：进程名，进程优先数，轮转时间片，进程所占用的CPU时间，进程的状态，当前队列指针等。可根据实验的不同，PCB结构的内容可以作适当的增删。 主体程序
操作系统-进程管理实验（2）
张毅轩的博客
01-03 1万+
实验二  进程管理 一、目的 本课题实验的目的是，加深对进程概念及进程管理各个部分内容的理解；熟悉进程管理中主要数据结构的设计及进程调度算法，进程控制机构，同步机构，通信机构的实施。 二、题目 进程管理 三、要求及提示 1、要求设置PCB，进程控制原语，进程调度算法，能描述进程调度中不同进程状态之间的转换，设计一个允许n个进程并发运行的进程管理模拟系统。该系统包括有简单的进程控制，同步
操作系统实验： 进程管理
qq_50542009的博客
06-26 1万+
一．实验目的： 1. 加深对进程概念的理解，明确进程与程序的区别。 2.进一步理解并发执行的实质。 3.分析进程争用系统资源的情况，学习解决进程互斥的方法。 4.了解Linux中进程通信的基本方法。 二．实验要求： 在linux系统上用C语言编写程序，分析程序运行结果及原因，加深对进程管理的理解。 实验内容： 进程的创建 编写一段程序，使用系统调用fork() 创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示字符“a”，子...
操作系统实验五：用户进程管理（详细分析）
weixin_43973089的博客
04-16 3525
操作系统实验五：用户进程管理一、 实验目的二、 实验任务三、 实验准备1.alloc_proc() 函数2.do_fork() 函数3.idt_init() 函数4.trap_dispatch() 函数四、 实验步骤（一） 练习0:填写已有实验（二） 练习1: 加载应用程序并执行1.设计分析**2.设计实现**2.1. load_icode 函数分析:2.2. 注释分析2.3. 代码实现3.问题简答（三） 练习2: 父进程复制自己的内存空间给子进程1.函数调用分析2.代码实现**2.1. 实现思路：**2.
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

十亿少男的梦421

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值