操作系统实验报告--实验一--进程管理.doc

实验一 进程管理
一、目的
进程调度是处理机管理的核心内容。本实验要求编写和调试一个简单的进程调度程序。通过本实验加深理解有关进程控制块、进程队列的概念，并体会和了解进程调度算法的具体实施办法。
二、实验内容及要求
1、设计进程控制块PCB的结构（PCB结构通常包括以下信息：进程名（进程ID）、进程优先数、轮转时间片、进程所占用的CPU时间、进程的状态、当前队列指针等。可根据实验的不同，PCB结构的内容可以作适当的增删）。为了便于处理，程序中的某进程运行时间以时间片为单位计算。各进程的轮转时间数以及进程需运行的时间片数的初始值均由用户给定。
2、系统资源(r1…rw),共有w类，每类数目为r1…rw。随 机产生n进程Pi(id,s(j,k)，t),0<=i<=n,0<=j<=m,0<=k<=dt为总运行时间，在运行过程中，会随机申请新的资源。
3、每个进程可有三个状态（即就绪状态W、运行状态R、等待或阻塞状态B），并假设初始状态为就绪状态。建立进程就绪队列。
4、编制进程调度算法：时间片轮转调度算法
本程序用该算法对n个进程进行调度，进程每执行一次，CPU时间片数加1，进程还需要的时间片数减1。在调度算法中，采用固定时间片（即：每执行一次进程，该进程的执行时间片数为已执行了1个单位），这时，CPU时间片数加1，进程还需要的时间片数减1，并排列到就绪队列的尾上。
三、实验环境
操作系统环境：Windows系统。
编程语言：C#。
四、实验思路和设计
1、程序流程图

对进程进行初始化，建立就绪队列、阻塞队列。Input()
触发时钟，调用时间片轮转调度算法。runFcfs()
取就绪队列的第一个进程，判断其运行的时间片是否达到所需次数。如果达到，则释放资源
如果没达到，则运行一个时间片。running()
输出就绪队列和阻塞队列的信息。outputall()
就绪队列为空？
检查阻塞队列，对于当前资源数目满足阻塞队列的进程，由阻塞转入就绪队列。testblock()
检查是否有新进程产生，如果有，则判断系统资源是否够用，如果够用，则分配给该进程，插入就绪队列。如果不够用，则插入阻塞队列。testnew()
显示三类资源情况。rescore()
结束
开始
是
否

2、主要程序代码
//PCB结构体
struct pcb
{
public int id; //进程ID
public int ra; //所需资源A的数量
public int rb; //所需资源B的数量
public int rc; //所需资源C的数量
public int ntime; //所需的时间片个数
public int rtime; //已经运行的时间片个数
public char state; //进程状态，W（等待）、R（运行）、B（阻塞）
//public int next;
}
ArrayList hready = new ArrayList();
ArrayList hblock = new ArrayList();
Random random = new Random();
//ArrayList p = new ArrayList();
int m, n, r, a,a1, b,b1, c,c1, h = 0, i = 1, time1Inteval;//m为要模拟的进程个数，n为初始化进程个数
//r为可随机产生的进程数（r=m-n）
//a，b，c分别为A，B，C三类资源的总量
//i为进城计数，i=1…n
//h为运行的时间片次数，time1Inteval为时间片大小（毫秒）

//对进程进行初始化，建立就绪数组、阻塞数组。
public void input()//对进程进行初始化，建立就绪队列、阻塞队列
{
m = int.Parse(textBox4.Text);
n = int.Parse(textBox5.Text);
a = int.Parse(textBox6.Text);
b = int.Parse(textBox7.Text);
c = int.Parse(textBox8.Text);
a1 = a;
b1 = b;
c1 = c;
r = m - n;
time1Inteval = int.Parse(textBox9.Text);
timer1.Interval = time1Inteval;
for (i = 1; i <= n; i++)
{
pcb jincheng = new pcb();
jincheng.id = i;
jincheng.ra = (random.Next(a) + 1);
jincheng.rb = (random.Next(b) + 1);
jincheng.rc = (random.Next(c) + 1);
jincheng.ntime = (random.Next(1, 5));
jincheng.rtime = 0;
listBox1.Items.Add("产生进程ID：" + jincheng.id);
listBox1.Items.Add("所需A资源数目：" + jincheng.ra);
listBox1.Items.Add("所需B资源数目：" + jincheng.rb);
listBox1.Items.Add("所需C资源数目：" + jincheng.rc);
listBox1.Items.Add("所需时间片数：" + jincheng.ntime);

if ((a - jincheng.ra) >= 0 && (b - jincheng.rb) >= 0 && (c - jincheng.rc) >= 0)
{
a = a - jincheng.ra;
b = b - jincheng.rb;
c = c - jincheng.rc;
jincheng.state = 'W';
hready.Add(jincheng);//加入就绪队列
}
else
{
jincheng.state = 'B';
hblock.Add(jincheng);//加入阻塞队列
}
listBox1.Items.Add("当前进程状态：" + jincheng.state);
}
}
//从数组起始地址开始输出该数组的内容
public void disp(ArrayList list)
{
ArrayList list1 = new ArrayList();
list1 = list;
if (list1.Count > 0)
{
for (int j = 0; j < list1.Count; j++)
{
pcb p = (pcb)list1[j];
listBox1.Items.Add(" " + p.id.ToString() + " " + p.state.ToString() + " " + p.ra.ToString() + " " + p.rb.ToString() + " " + p.rc.ToString()+" " + p.ntime.ToString() + " " + p.rtime.ToString() + " \r\n");
}
}
else
{
listBox1.Items.Add("\r\n\t 该队列中没有进程！\r\n");
}
}
//输出就绪数组和阻塞数组的信息
public void outputall()
{
listBox1.Items.Add("\r\n=======CPU运行了：" + h.ToString() + "次=======\r\n");
listBox1.Items.Add("*********当前就绪队列的信息！*********");
listBox1.Items.Add("进程ID 进程状态 A资源数 B资源数 C资源数 所需时间片 已运行时间片");
disp(hready);
listBox1.Items.Add("*********当前就阻塞列的信息！*********");
listBox1.Items.Add("进程ID 进程状态 A资源数 B资源数 C资源 所需时间片 已运行时间片");
disp(hblock);
}

//运行就绪数组的头进程，运行一个时间片，轮转一个时间片，时间片轮转调度算法
public void running()
{
ArrayList hready1 = new ArrayList();
hready1 = hready;
pcb p1 = new pcb();
p1=(pcb)hready1[0];
p1.state='R';
p1.rtime= p1.rtime + 1;
h=h+1;
listBox1.Items.Add("\r\n~~~~~~~当前正在运行进程ID是:" +p1.id + "~~~~~~~~\r\n");
listBox1.Items.Add("\r\n进程ID 进程状态 A资源数 B资源数 C资源数 所需时间片 已运行时间片\r\n");
listBox1.Items.Add(p1.id + " " +p1.state+ " " + p1.ra + " " + p1.rb + " " + p1.rc + " " + p1.ntime + " " + p1.rtime);
if (p1.ntime==p1.rtime)
{
listBox1.Items.Add(p1.id.ToString()+"的进程已经完成！\r\n");
a = a + p1.ra;
b = b + p1.rb;
c = c + p1.rc;
hready.RemoveAt(0);
}
else
{
p1.state='W';
hready1.Add(p1);
hready.RemoveAt(0);
}
}
//检测当前资源数目是否满足阻塞数组里进程的需求
public void testblock()
{
ArrayList hblock1 = new ArrayList();
hblock1 = hblock;
for (int m = 0; m < hblock1.Count; m++)
{
pcb p1 = new pcb();
p1 = (pcb)hblock1[m];
if ((a - p1.ra >= 0) && (b - p1.rb >= 0) && (c - p1.rc >= 0))
{
p1.state='W';
hready.Add(p1);
a = a - p1.ra;
b = b - p1.rb;
c = c - p1.rc;
listBox1.Items.Add("ID号为："+p1.id + "的进程由阻塞队列转入就绪队列~~\r\n");
hblock.RemoveAt(m);
m--;
}
}
}
//检测是否有新的进程产生，随机产生新进程
public void testnew()
{
int t;
if (r>0)//r为随机产生的进程数目
{
t = random.Next(9) + 1;
if (t <= 7)
{
listBox1.Items.Add("\r\n有新的进程申请加入：~~");
pcb jincheng = new pcb();
jincheng.id = i++;
jincheng.ra = (random.Next(a) + 1);
jincheng.rb = (random.Next(b) + 1);
jincheng.rc = (random.Next(c) + 1);
jincheng.ntime = (random.Next(1, 5));
jincheng.rtime = 0;
listBox1.Items.Add("产生进程ID：" + jincheng.id);
listBox1.Items.Add("所需A资源数目：" + jincheng.ra);
listBox1.Items.Add("所需B资源数目：" + jincheng.rb);
listBox1.Items.Add("所需C资源数目：" + jincheng.rc);
listBox1.Items.Add("所需时间片数：" + jincheng.ntime);
if ((a - jincheng.ra) >= 0 && (b - jincheng.rb) >= 0 && (c - jincheng.rc) >= 0)
{
a = a - jincheng.ra;
b = b - jincheng.rb;
c = c - jincheng.rc;
jincheng.state = 'W';
listBox1.Items.Add("进程状态为：" + jincheng.state);
hready.Add(jincheng);//加入就绪队列
listBox1.Items.Add("资源满足新进程请求，该进程进入就绪队列~~\r\n");
}
else
{
jincheng.state = 'B';
hblock.Add(jincheng);//加入阻塞队列
listBox1.Items.Add("进程状态为：" + jincheng.state);
listBox1.Items.Add("资源不满足新进程请求，该进程进入阻塞队列~~\r\n");
}
}
}
r = r - 1;
}
//系统三类资源变化情况的显示
public void rescore()//系统三类资源变化情况的显示
{
if (a > a1) { textBox1.Text = a1.ToString(); }
if (a < 0) { textBox1.Text = "0"; }
if (a >= 0 && a < a1) { textBox1.Text = a.ToString(); }
if (b > b1) { textBox2.Text = b1.ToString(); }
if (b < 0) { textBox2.Text = "0"; }
if (b >= 0 && b <= b1) { textBox2.Text = b.ToString(); }
if (c > c1) { textBox3.Text = c1.ToString(); }
if (c < 0) { textBox3.Text = "0"; }
if (c >= 0 && c <= c1) { textBox3.Text = c.ToString(); }
}
//时间片轮转调度算法（先来先服务FCFS算法）
public void runFcfs()
{
if (hready.Count>0)
{
outputall();
running();
testblock();
testnew();
rescore();
}
else
{
timer1.Enabled = false;
textBox1.Text = a1.ToString();
textBox2.Text = b1.ToString();
textBox3.Text = c1.ToString();
listBox1.Items.Add("\r\n<<<<<<<<所有进程都已经运行结束！>>>>>>>~\r\n");
}
//计时器触发时间片轮转调度算法
private void timer1_Tick(object sender, EventArgs e)
{
runFcfs();
}

//开始模拟按钮单击执行函数
private void button1_Click(object sender, EventArgs e)
{
runmain();
button1.Enabled = false;
textBox1.Enabled = false;
textBox2.Enabled = false;
textBox3.Enabled = false;
textBox4.Enabled = false;
textBox5.Enabled = false;
textBox6.Enabled = false;
textBox7.Enabled = false;
textBox8.Enabled = false;
textBox9.Enabled = false;
}
//清除屏幕按钮单击执行函数
private void button2_Click(object sender, EventArgs e)
{
textBox1.Text = "";
textBox2.Text = "";
textBox3.Text = "";
textBox4.Text = "";
textBox5.Text = "";
textBox6.Text = "";
textBox7.Text = "";
textBox8.Text = "";
textBox9.Text = "";
listBox1.Items.Clear();
textBox4.Enabled = true;
textBox5.Enabled = true;
textBox6.Enabled = true;
textBox7.Enabled = true;
textBox8.Enabled = true;
textBox9.Enabled = true;
button1.Enabled = true;
}

//运行的主函数
public void runmain()
{
input();
imer1.Enabled = true；
}

3、运行界面和运行结果
界面中，可以任意设定需要模拟的进程总数（如5），初始化进程个数（如3），还有A、B、C三类资源的总数（如10、10、10）。为了方便显示，还可以设定时间片的长度（如500毫秒）。除此之外，在运行过程中，所有的资源都是随机生成的，并且其中新进程的产生也是随机的，但是产生的进程总数不会多于开始设定的模拟的进程总数，以防止不断产生新进程，程序不断运行。在显示窗口的上方，还会实时显示资源的变化情况，方便对运行的观察。当运行结束后，可以通过工具栏中的显示选项中的保存结果按钮，将结果保存成txt文件格式，方便运行后的结果分析。
五、心得体会
本次实验，我的任务是设计一个允许n个进程并发运行的进程管理模拟系统。该系统包括有简单的进程控制、同步与通讯机构，系统在运行过程中能显示各进程的状态及有关参数的变化情况，从而观察诸进程的运行过程及系统的管理过程，我是用C#写的，在我的电脑能够运行通过，虽不能尽善尽美，但也基本能实现老师的要求。
两个星期的实验，虽然时间有点短，但我也收获不少，这次实验，加深了我对进程概念及进程管理的理解；比较熟悉进程管理中主要数据结构的设计及进程调度算法、进程控制机构、同步机构及通讯机构的实施。也让我认识到自己的不足，操作系统的有些知识，我知道的还不多，没有掌握好，还需要多多学学，不断提升自己的能力。
实验中，我们小组分工合作，共同学习，虽然在实验中遇到了一些问题，但在老师和同学的细心指导和热心帮助下解决了。同时，了解到团队精神的重要性，也为以后的学习和工作打下了坚实的基础，同时积累了宝贵的经验。