要求：通过进程管理子系统案例的演示与操作步骤，掌握在 Linux 系统下创建进程并管理进程，并能根据自己的设计在 shell 命令行中管理进程。

下载：Linux操作系统 实现一个进程管理子系统 源代码

1 项目概述

1.1 项目介绍

现代计算机系统中，进程是资源分配和独立运行的基本单位，是操作系统的核心概念。进程调度是进程管理过程的主要组成部分，是必然要发生的事件。在现代操作系统中，进程的并发机制在绝大多数时候，会产生不断变化的进程就绪队列和阻塞队列。处于执行态的进程无论是正常或非正常终止、或转换为阻塞状态，都会引发从就绪队列中，由进程调度选择一个进程进占CPU。

本项目在 Linux 系统下创建进程并管理进程，在 shell 命令行中管理进程。通过编程实现操作系统进程调度子系统的基本功能，其中，必须实现的调度算法有:先来先服务、时间片轮转、多级反馈轮转法、优先级等，在程序设计过程中，在每个调度算法展示时，可以看到所有有关的队列结构和其中的内容，如就绪队列、阻塞队列等结构的动态变化的过程。

1.2 项目目的

课程设计是计算机科学与技术专业实践性环节之一，是学习完《操作系统》课程后进行的一次较全面的综合练习。目的在于加深对操作系统的理论、方法和基础知识的理解，掌握操作系统结构、实现机理和各种典型算法，系统地了解操作系统的设计和实现思路，培养我们的系统设计能力，并了解操作系统的发展动向和趋势。

1.3 项目开发环境

我们的项目基于Linux进行开发，需要事先安装好开发环境。

• Git 项目源码管理。我们采用了github作为Git服务器，便于大家交换代码
• VMware Workstation Pro v16.0.0 虚拟机软件。VMware是功能最强大的虚拟机软件，用户可在虚拟机同时运行各种操作系统，进行开发、测试、演示和部署软件。
• Ubuntu 18.04 LTS。Ubuntu是一个以桌面应用为主的GNU/Linux操作系统。
• PuTTY 0.75。PuTTY是一个Telnet/SSH/rlogin/纯TCP以及串行阜连线软件，多用于远程登录控制功能。
• MTPuTTY 1.8.0.224。MTPuTTY用于管理不同的PuTTY连接,使用一个标签式的用户界面。每个 PuTTY 连接运行在不同的标签,你可以方便地切换它们。
• Zsh 5.8。Zsh是一种专为交互使用而设计的 shell，它也是一种强大的脚本语言。
• oh my zsh。oh-my-zsh是基于zsh的功能做了一个扩展，方便的插件管理、主题自定义，以及漂亮的自动完成效果。

系统配置:

系统：Windows 10 (64bit)

处理器：Intel CPU Core i5-2500K 3.3 GHz

内存：16 GB RAM

显卡：Nvidia GPU GeForce GTX 1650

存储：15 GB of available space

2 需求分析

2.1 系统需求分析

1.加深对进程概念的理解，明确进程和程序的区别。

2.进一步认识并加强进程管理中主要数据结构的设计及进程调度算法。

3.分析进程竞争资源现象，学习解决进程互斥的方法。

4.观察和管理进程——系统在运行过程中可显示或打印各进程的状态及有关参数的变化情况。

2.2 可行性分析

1.项目的目标

项目目标：实现一个进程管理子 ，通过编程实现操作系统进程调度子系统的基本功能，其中，必须实现的调度算法有:先来先服务、时间片轮转、多级反馈轮转法、优先级等，在程序设计过程中，在每个调度算法展示时，可以看到所有有关的队列结构和其中的内容，如就绪队列、阻塞队列等结构的动态变化的过程。

2.设计目的

通过模拟操作系统原理的实现，加深对操作系统工作原理和操作系统实现方法的理解；通过模拟操作系统原理的实现练习编程。

3.任务和要求

(1)良好的沟通和合作能力；

(2)充分利用课上所学的操作系统、程序设计、数据结构等相关知识；

(3)充分利用调试和排错技术；

(4)简单测试驱动模块和桩模块的编写；

(5)查阅相关资料，自学具体课题中涉及的新知识。

2.3 项目实施安排

3 系统设计

3.1 系统结构设计

3.2 系统功能模块设计

1.创建进程——根据进程的顺序依次放入就绪队列；

2.执行进程——管理系统将就绪队列中的第一个进程调入运行队列；

3.将阻塞队列中进程调入就绪队列；

4.封锁进程——管理系统将就绪队列中的第一个进程调入阻塞队列；

5.结束进程——管理系统撤销所选进程。

3.3 进程总体设计

为创建进程，执行进程，将阻塞队列中进程调入就绪队列，封锁进程，撤销已结束的进程，以及控制进程在运行过程中的状态转换：

1.进程创建的主要工作是：

(1)申请空白进程控制块；

(2)程序装入pcb//内存申请；

(3)初始化进程控制块；

(4)将进程链入就绪队列。

2.进程撤销的主要工作是：

(1)将结果写入out文件；

(2)回收进程控制块。

3.4 数据结构

类：

class queuenode

class queue

函数：

void enqueue( char &item);

char dequeue();

void del(char item);

void display();

int find(char item);

int isempty()

3.5 程序源代码

程序源代码
#include 
#include 

using namespace std;
class queuenode
{
	friend class queue;

private:
	char data;
	queuenode* link;
	queuenode(char d = 0, queuenode* l = NULL) : data(d), link(l) {}
};

class queue
{
public:
	queue() : rear(NULL), front(NULL) {};
	~queue();
	void enqueue(char& item);
	char dequeue();
	void del(char item);
	void display();
	int find(char item);
	int isempty() { return front == NULL; }

private:
	queuenode* front, * rear;
};

queue::~queue()
{
	queuenode* p;
	while (front != NULL)
	{
		p = front;
		front = front->link;
		delete p;
	}
}
void queue::enqueue(char& item)
{
	if (front == NULL)
		front = rear = new queuenode(item, NULL);
	else
		rear = rear->link = new queuenode(item, NULL);
}
char queue::dequeue()
{
	queuenode* p = front;
	char f = p->data;
	front = front->link;
	delete p;
	return f;
}

void queue::display()
{
	queuenode* p;
	p = front;
	while (p != NULL)
	{
		cout << p->data << "->";
		p = p->link;
	}
	cout << "NULL";
}

int queue::find(char item)
{
	queuenode* w;
	w = front;
M:
	while (w != NULL)
	{
		if (item == w->data)
		{
			return 1;
			break;
		}
		else
		{
			w = w->link;
			goto M;
			return 0;
		}
	}
	if (w == NULL)
		return 0;
}

void queue::del(char item)
{
	queuenode* q, * b;
	q = front;
	while (q->data != item)
	{
		b = q;
		q = q->link;
	}
	if (q == front)
	{
		front = front->link;
		delete q;
	}
	else if (q == rear)
	{
		rear = b;
		rear->link = NULL;
		delete q;
	}
	else
	{
		b->link = q->link;
		delete q;
	}
}

int main()
{
	int n;
	char a;
	cout << "\n[-----------操作系统之进程管理模拟系统（先来先服务算法）------------]\n"
		<< endl;
	queue execute, ready, clog; //执行，就绪，阻塞
	cout << "\n[-------请用户输入进程名及其到达cpu的顺序（结束进程数请输入x）------]\n"
		<< endl;
	char r;
	r = 'x';
	for (int i = 0;; i++)
	{
		char e[100];
		cout << "输入进程名:"
			<< " ";
		cin >> e[i];
		if (e[i] != r)
			ready.enqueue(e[i]);
		else
			break;
	}
A:
	cout << "\n  [------------请用户选择操作------------]\n";
	cout << "\n [1、执行进程……2、将阻塞队列中进程调入就绪队列………]\n";
	cout << "\n [3、封锁进程…………………4、结束进程 …………………]\n";
	cout << "\n [5、退出程序………………………………………………… ]\n选项： ";
	cin >> n;
	if (n == 1)
	{
		if (!execute.isempty())
		{
			cout << "已经有进程在执行！,此操作不能执行\n";
			char w;
			cout << endl;
			cout << "如果要继续请输入#；如果要退出按其它任意键 " << endl;
			cout << "要选择的操作:";
			cin >> w;
			if (w == '#')
				goto L;
			else
				goto E;
		}
		else
		{
			if (!ready.isempty())
			{
				a = ready.dequeue();
				if (a != r)
					execute.enqueue(a);
				goto L;
			}
			else
				goto L;
		}
	}
	else if (n == 2)
	{
		if (!clog.isempty())
		{
			a = clog.dequeue();
			if (a != r)
				ready.enqueue(a);
			goto L;
		}
		else
			goto L;
	}
	else if (n == 3)
	{
		if (!execute.isempty())
		{
			a = execute.dequeue();
			if (a != r)
				clog.enqueue(a);
			goto L;
		}
		else
			goto L;
	}
	else if (n == 4)
	{
		cout << "\n请输入要结束的进程名： ";
		cin >> a;
		if (execute.find(a) || ready.find(a) || clog.find(a))
		{
			if (execute.find(a))
			{
				execute.del(a);
			}
			else if (ready.find(a))
			{
				ready.del(a);
			}
			if (clog.find(a))
			{
				clog.del(a);
			}
			cout << "\n结束进程成功！\n"
				<< endl;
			goto L;
		}
		else
			cout << "没有此进程 " << endl;
		goto L;
	L:
		if (n == 1 || n == 2 || n == 3 || n == 4)
		{
			cout << "执行队列" << endl;
			execute.display();
			cout << endl;
			cout << "就绪队列" << endl;
			ready.display();
			cout << endl;
			cout << "阻塞队列" << endl;
			clog.display();
			cout << endl;
			goto A;
		}
		else if (n == 5)
			;
		else
		{
			cout << "\n你的输入错误！\n";
			goto A;
		}
	}
E:;
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251

4 系统功能说明

4.1 系统功能介绍

Shell是种命令解释程序，也可以看作是一种命令语言的解释器。 用户在与Shell交互时所输入的命令行必须符合Shell命令的语法和语义规范，才能够被Shell理解并执行。

Shell所使用的这种命令语言称为Shell 语言。Shell语言不仅仅是一种交互式语言， 它还是一种可编程的程序设计语言。将若干个Shell命令行写入个文件就构成了一个Shell程序，它可以被Shell逐条地解释执行。用Shell语言编写的Shell程序可以使用各种变量、参数和控制结构来组织命令流程，自动化地完成各种复杂冗繁的处理工作。

Linux系统中广泛使用了Shell程序来实现系统的初启、配置、管理和维护等工作。用户通过Ubuntu运行该程序。需说明的是主函数是实现进程管理的入口，在入口处需输入进程名称，然后输入进程的状态选项，如果完毕后，则通过相应的调度算法进行进程机的调度，同时也将结果显示在屏幕上。

本系统通过模拟多个进程的同步运行，实现了进程就绪，运行，阻塞三个状态的转换，并可以根据用户要求改变进程的状态。

4.2 系统实现原理

通过在Linux系统中，利用Shell语言编译程序，定义PCB的数据结构，用链表的形式管理进程，采用多级反馈队列调度的算法模拟进程的控制，最终完成有创建、撤销、调度、阻塞、唤醒进程等功能。

4.3 功能实现说明

1.程序运行界面

cout << "\n  [------------请用户选择操作------------]\n";
	cout << "\n [1、执行进程……2、将阻塞队列中进程调入就绪队列………]\n";
	cout << "\n [3、封锁进程…………………4、结束进程 …………………]\n";
	cout << "\n [5、退出程序………………………………………………… ]\n选项： ";
	cin >> n;
1
2
3
4
5

2.执行进程

int main()
{
	int n;
	char a;
	cout << "\n[-----------操作系统之进程管理模拟系统（先来先服务算法）------------]\n"
		<< endl;
	queue execute, ready, clog; //执行，就绪，阻塞
	cout << "\n[-------请用户输入进程名及其到达cpu的顺序（结束进程数请输入x）------]\n"
		<< endl;
	char r;
	r = 'x';
	for (int i = 0;; i++)
	{
		char e[100];
		cout << "输入进程名:"
			<< " ";
		cin >> e[i];
		if (e[i] != r)
			ready.enqueue(e[i]);
		else
			break;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3.将阻塞队列的进程调入就绪队列

if (n == 2)
	{
		if (!clog.isempty())
		{
			a = clog.dequeue();
			if (a != r)
				ready.enqueue(a);
			goto L;
		}
		else
			goto L;
	}
1
2
3
4
5
6
7
8
9
10
11
12

4.封锁进程

if (n == 3)
	{
		if (!execute.isempty())
		{
			a = execute.dequeue();
			if (a != r)
				clog.enqueue(a);
			goto L;
		}
		else
			goto L;
	}
1
2
3
4
5
6
7
8
9
10
11
12

5.结束进程

if (n == 4)
	{
		cout << "\n请输入要结束的进程名： ";
		cin >> a;
		if (execute.find(a) || ready.find(a) || clog.find(a))
		{
			if (execute.find(a))
			{
				execute.del(a);
			}
			else if (ready.find(a))
			{
				ready.del(a);
			}
			if (clog.find(a))
			{
				clog.del(a);
			}
			cout << "\n结束进程成功！\n"
				<< endl;
			goto L;
		}
		else
			cout << "没有此进程 " << endl;
		goto L;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

6.界面输出及退出操作

if (n == 1 || n == 2 || n == 3 || n == 4)
		{
			cout << "执行队列" << endl;
			execute.display();
			cout << endl;
			cout << "就绪队列" << endl;
			ready.display();
			cout << endl;
			cout << "阻塞队列" << endl;
			clog.display();
			cout << endl;
			goto A;
		}
		else if (n == 5)
			;
		else
		{
			cout << "\n你的输入错误！\n";
			goto A;
		}
	}
E:;
	return 0;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

5 系统测试
1.Shell命令编译程序，生成可执行文件

2.执行程序

3.进程创建以及实现进程堵塞

4.查看执行进程

5.封锁进程，实现阻塞

6.对堵塞中的进程，选中进程调入就绪队列

7.将就绪队列进程执行

8.结束进程

9.退出程序

6 用户使用说明

1.本程序执行文件为“ProcessManagement”。

2.进入本系统之后，随即显示系统主菜单界面。用户可在该界面下输入各子菜单前对应的数字并按下回车键，执行相应子菜单命令。

(1)创建进程——根据进程的顺序依次放入就绪队列；

(2)执行进程——管理系统将就绪队列中的第一个进程调入运行队列；

(3)将阻塞队列中进程调入就绪队列；

(4)封锁进程——管理系统将就绪队列中的第一个进程调入阻塞队列；

(5)结束进程——管理系统撤销所选进程；

3.根据程序的提示即可完成进程管的各项功能。

7 总结

本次课程设计是实现一个进程管理的系统，该系统包括硬件工作的模拟、模拟中断的种类和中断处理方式、进程控制等，从而观察诸进程的运行过程。 系统通过模拟多个进程的同步运行，实现了进程就绪，运行，阻塞三个状态的转换，并可以根据用户要求改变进程的状态。用户通过Ubuntu运行该程序。需说明的是主函数是实现进程管理的入口，在入口处需输入进程名称，然后输入进程的状态选项，如果完毕后，则通过相应的调度算法进行进程机的调度，同时也将结果显示在屏幕上。

课程设计初期遇到了很多困难，不知道从何下手，在同学的帮助和自己摸索的情况下还是完成了这次课程设计，从中认识到以我们现在的经验，不学到一定的深度和广度是难以在实际工作中应付自如的。因此反映出学习的还不够，缺点疏漏。需在加以刻苦钻研及学习，不断开拓视野，增强自己的实践操作技能。

这次课程设计，加深了我对进程概念及进程管理的理解；比较熟悉进程管理中主要数据结构的设计及进程调度算法、进程控制机构等。操作系统的只是很深奥，仅靠课本是远远不够的，我将出现的所有错误都写成了博客发布到CSDN上，总结经验，不断提升自己的能力。

下载：Linux操作系统 实现一个进程管理子系统 源代码