操作系统实验四 进程间通信

★观前提示：本篇内容为操作系统实验内容，代码等内容经测试没有问题，但是可能会不符合每个人实验的要求，因此以下内容建议仅做思路参考。

目录

• • • • 一、实验目的
      • 二、实验内容
      • 三、具体实现
      • 四、实验总结

一、实验目的

多道程序设计中，往往有若干个进程同时处于就绪状态。当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。本实验要求学生：

1. 理解进程的各个状态、进程控制块PCB的结构。
2. 理解处理机调度算法，模拟在单处理器情况下的处理器调度。

二、实验内容

1. 设计一个按优先数调度算法实现处理器调度的程序。

2. 设计一个按时间片轮转法实现处理器调度的程序。

三、具体实现

1️⃣设计一个按优先数调度算法实现处理器调度的程序。

①程序设计清单

#include
#include
#include
#include
using namespace std;
//-----------------------
struct _proc //定义一个结构体表示进程的PCB
{
	char name[32]; //进程名
	struct _proc* next; //指向下一个PCB的指针
	int run_time; // 要求运行的时间
	int priority; // 优先数
	int state;//进程状态
};
_proc* root;

//向就绪队列中插入进程,按照降序
void Insert(_proc* pr)
{
	_proc* q = root;
	_proc* p = root->next;
	if (root->state != 0)
	{
		while (p != NULL)
		{
			if (p->priority > pr->priority)
			{
				q = p;
				p = p->next;
			}
			else
			{
				break;
			}
		}
	}
	pr->next = p;//插入进程结点
	q->next = pr;
	++root->state;//进程个数加1
}

//创建进程
_proc Creat(const char name[], int priority, int run_time)
{
	_proc pr;
	strcpy(pr.name, name);
	pr.priority = priority;
	pr.run_time = run_time;
	pr.state = 0;
	pr.next = NULL;
	return pr;
}

//删除就绪队列中队首进程
_proc* Delete()
{
	_proc* pr = root->next; //此时pr为指向结构体的指针，指向队首进程
	root->next = root->next->next;
	--root->state; //进程个数减1
	return pr; //返回被删除进程的地址
}

//对就绪队列排序,按照降序
void Sort()
{
	if (root->next->run_time == 0)//队首进程的要执行时间为0时，从就绪队列中删除该进程
	{
		Delete();
		root->next->state = 1;
	}
	else//不为0时，先删除，再根据变化后的优先级，插入到相应位置
	{
		_proc* pr = Delete();
		Insert(pr);
	}
}

void OutPut()
{ //取队首的进程，模拟进程执行，输出执行进程名
	printf("%s\n", root->next->name);
	--root->next->priority;//动态改变优先数，优先级减1
	--root->next->run_time;//运行时间减1
}

void Solve()
{ //定义根结点，指向第一个进程
	root = new _proc;
	root->state = 0;//队列中的进程个数
	root->next = NULL;
	//创建几个进程,并插入就绪队列
	_proc pr1 = Creat("p1", 2, 1);
	Insert(&pr1);
	_proc pr2 = Creat("p2", 3, 5);
	Insert(&pr2);
	_proc pr3 = Creat("p3", 1, 3);
	Insert(&pr3);
	_proc pr4 = Creat("p4", 2, 4);
	Insert(&pr4);
	_proc pr5 = Creat("p5", 4, 2);
	Insert(&pr5);
	printf("调度序列：\n"); //输出
	while (root->state != 0)
	{
		OutPut(); //取队首进程模拟执行一个单位时间数
		Sort(); //重新排序
	}
}
int main()
{
	Solve();
	getchar();
	getchar();
	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

②编写完程序后，保存并退出

③编译程序

④实验结果输出

⑤程序分析及说明

处理器调度总是选队首进程运行。采用动态改变优先数的办法，进程每运行一次优先数就减“1”。由于本实验是模拟处理器调度，
所以，对被选中的进程并不实际的启动运行，只进行相应的参数的修改，即执行：优先数-1，要求运行时间-1来模拟进程的一次运行。

说明：在实际的系统中，当一个进程被选中运行时，必须恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行结束。

2️⃣设计一个按时间片轮转法实现处理器调度的程序。

①程序设计清单

#include
#include
#include
#include
using namespace std;
//-----------------------
struct _proc //定义一个结构体表示进程的PCB
{
	char name[32]; //进程名
	struct _proc* next; //指针
	int run_time; //要求运行的时间
	int alloc_time; //已运行的时间
	int state;//进程状态
};
_proc* root;

//向就绪队列中插入进程,按照降序
void Insert(_proc* pr)
{
	if (root->next == NULL)
	{
		root = pr;
		pr->next = pr;
		return;
	}
	pr->next = root->next;//插入
	root->next = pr;
	root = pr;
}

//创建进程
_proc Creat(char name[], int run_time, int alloc_time)
{
	_proc pr;
	strcpy(pr.name, name); //进程名取参数名
	pr.run_time = run_time; //取参数的要求运行时间
	pr.alloc_time = alloc_time; //取参数的已运行时间
	pr.state = 0;
	pr.next = NULL;
	return pr;
}

//删除就绪队列中对首进程
void Delete()
{
	if (root->next == root)
	{ //队列已为空
		root = NULL;
		return;
	}
	root->next = root->next->next;
}

//输出进程号,模拟进程执行
void OutPut()
{
	cout << root->next->name << endl;//输出
	++root->next->alloc_time;//已运行时间加1
}
void Solve()
{ //定义根结点，指向下一个运行的进程
	root = new _proc;
	root->state = 0;//队列中的进程个数
	root->next = NULL;
	//创建几个进程,并插入就绪队列
	_proc pr1 = Creat("Q1", 2, 1);
	Insert(&pr1);
	_proc pr2 = Creat("Q2", 3, 0);
	Insert(&pr2);
	_proc pr3 = Creat("Q3", 1, 0);
	Insert(&pr3);
	_proc pr4 = Creat("Q4", 2, 0);
	Insert(&pr4);
	_proc pr5 = Creat("Q5", 4, 0);
	Insert(&pr5);
	cout << "调度序列：" << endl; //输出
	while (root != NULL)//一直循环遍历
	{
		OutPut();//执行root指向的进程
		if (root->next->alloc_time == root->next->run_time)//执行完毕
		{
			Delete();//从就绪队列中删除该进程
			continue;
		}
		root = root->next;//root指针后移，执行下一个进程做准备
	}
}
int main()
{
	Solve();
	getchar();
	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

②编写完程序后，保存并退出

③编译程序

④实验结果输出

⑤程序分析及说明

处理器调度总是选择标志单元指示的进程运行。由于本实验是模拟处理器调度的功能，所以，对被选中的进程并不实际的启动运行，只进行相应的参数的修改，即执行：已运行时间+1来模拟进程的一次运行，表示进程已经运行过一个单位的时间。

说明：在实际的系统中，当一个进程被选中运行时，必须置上该进程可以运行的时间片值，以及恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行满一个时间片。在这时省去了这些工作，仅用“已运行时间+1”来表示进程已经运行满一个时间片。

四、实验总结

①理解了进程的各个状态、进程控制块PCB的结构，PCB进程控制块是进程的静态描述。
②理解了处理机调度算法，并借助程序模拟了在单处理器情况下的处理器调度。

2022.9.21记录：Code_流苏(CSDN)
如有任何疑问，评论回复，看到即回，欢迎大家多多交流学习！
★以上实验内容仅供参考。