0

前言

道程序设计中,经常是若干个进程同时处于就绪状态,为了使系统中的各进程有条不紊地运行,必须选择某种调度策略,以选择一个进程占用处理机。本次实验设计一个模拟单处理机调度的算法,以加深对处理机调度算法的理解。

要求

  1. 按照时间片轮转算法设计模拟调度程序。
  2. 输出进程的调度过程。

思路分析

由于本实验是按照处理机调度算法模拟实现处理机的调度,与真正的处理机调度过程并不完全相同,比如没有实现中断(时间片设为1),进程的运行也不是真正的运行,而是在屏幕上打印其运行时间等。所以要以文件的形式给出进程的信息,文件信息可参考如下:

进程ID  到达时间     估计运行时间     优先级
0        0             3               2
1        2             6               4
2        4             4               0
3        6             5               3
4        8             2               1  

以下是实验的大致思路:

  1. 建立三个队列:PCB队列,就绪队列,完成队列。

PCB队列:保存将进入系统的进程。(由于没有实现中断,所以将进入系统运行的进程必须在程序运行前给出)。
就绪队列:到达进程进入系统的时间,将该进程放入就绪队列,等待调度。
完成队列:将“运行”完的进程放入完成队列。

  1. 进程运行过程是在屏幕上打印相关信息。

使用轮转算法调度的进程应打印的信息包括:进程占用处理机序列,该进程每次占用处理机的开始时间与结束时间。

  1. 统计出进程的周转时间T和带权周转时间W。

流程图

实现代码

  1. ProcessControlBlock.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace OperatingSystemExperiment.Exp1 {
    enum ProcessStatus {
        Ready,
        Run,
        Finish
    }

    /// <summary>
    /// 进程控制块 PCB
    /// </summary>
    class ProcessControlBlock {
        /// <summary>
        /// 进程号
        /// </summary>
        public int ID;

        /// <summary>
        /// 进程状态
        /// </summary>
        public ProcessStatus Status;

        /// <summary>
        /// 进程到达时间
        /// </summary>
        public int ArriveTime;

        /// <summary>
        /// 估计运行时间
        /// </summary>
        public int Time;

        /// <summary>
        /// 已运行时间
        /// </summary>
        public int RunTime = 0;

        /// <summary>
        /// 等待时间
        /// </summary>
        public int WaitTime;

        /// <summary>
        /// 优先级
        /// </summary>
        public int Priority;

        /// <summary>
        /// 链接指针
        /// </summary>
        public ProcessControlBlock Next;

        /// <summary>
        /// 开始时间
        /// </summary>
        public int StartTime;

        /// <summary>
        /// 结束时间
        /// </summary>
        public int FinishTime;

        public void Run()
        {
            this.Status = ProcessStatus.Run;

            if (RunTime >= Time) {
                this.Status = ProcessStatus.Finish;
                return;
            }

            this.RunTime++;
        }

        public void Wait()
        {
            this.WaitTime++;
        }

        public override string ToString() => String.Format("{0} {1} {2}", ID, StartTime, FinishTime);
    }
}
  1. CentralProcessUnit.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;

namespace OperatingSystemExperiment.Exp1 {
    class CentralProcessUnit {
        private List<ProcessControlBlock> PCBList = new List<ProcessControlBlock>();
        private Queue<ProcessControlBlock> FinishQueue = new Queue<ProcessControlBlock>();
        private Queue<ProcessControlBlock> ReadyQueue = new Queue<ProcessControlBlock>();

        public CentralProcessUnit()
        {
            LoadPcbList();
        } 

        /// <summary>
        /// 生成进程列表
        /// </summary>
        /// <param name="count">进程数量</param>
        public static void GenerateProcessList(int count)
        {
            var processListFile = Path.Combine(Environment.CurrentDirectory, "process_list.txt");
            var writer = new StreamWriter(processListFile);
            var rnd = new Random(DateTime.Now.Millisecond);
            for (var i = 0; i < count; i++) {
                var runTime = rnd.Next(1, 10);
                writer.WriteLine("{0} {1} {2} {3}", i, Math.Pow(2, i), runTime, rnd.Next(0, 4));
            }

            writer.Close();
        }

        /// <summary>
        /// 加载PCB列表
        /// </summary>
        private void LoadPcbList()
        {
            var processListFile = Path.Combine(Environment.CurrentDirectory, "process_list.txt");
            var reader = new StreamReader(processListFile);
            while (!reader.EndOfStream) {
                var line = reader.ReadLine();
                var procInfo = line.Split(' ');
                PCBList.Add(new ProcessControlBlock {
                    ID = int.Parse(procInfo[0]),
                    ArriveTime = int.Parse(procInfo[1]),
                    Time = int.Parse(procInfo[2]),
                    Priority = int.Parse(procInfo[3])
                });
            }
        }

        /// <summary>
        /// CPU运行
        /// </summary>
        public void Run()
        {
            var times = 0;
            while (true) {
                // 如果所有进程运行完,则退出循环
                if (FinishQueue.Count == PCBList.Count) {
                    break;
                }

                // 遍历所有进程列表
                foreach (var p in PCBList) {
                    // 根据进程到达时间判定是否有新进程加入,然后将进程状态设置为就绪
                    if (p.ArriveTime == times++) {
                        Console.WriteLine("时间:{0},进程 {1} 到达", times, p.ID);
                        p.Status = ProcessStatus.Ready;
                    }

                    // 讲就绪状态进程加入就绪列表
                    if (p.Status == ProcessStatus.Ready) {
//                        Console.WriteLine("时间:{0},进程 {1} 加入就绪列表", times, p.ID);
                        ReadyQueue.Enqueue(p);
                    }

                    // 如果就绪队列为空则进入下一次循环
                    if (ReadyQueue.Count == 0) {
//                        Console.WriteLine("时间:{0},没有就绪进程,进入下一个循环", times);
                        continue;
                    }

                    // 从就绪队列中取出一个进程运行
                    var currentProcess = ReadyQueue.Dequeue();
                    Console.WriteLine("时间:{0},运行进程 {1}", times, p.ID);
                    currentProcess.Run();

                    // 将运行完毕进程加入完成列表
                    if (currentProcess.Status == ProcessStatus.Finish) {
                        Console.WriteLine("时间:{0},进程 {1} 运行完毕,总运行时间:{2}", times, p.ID, p.RunTime);
                        FinishQueue.Enqueue(currentProcess);
                    }
                    else
                        currentProcess.Status = ProcessStatus.Ready;
                }
            }
        }
    }
}
  1. Main.cs
namespace OperatingSystemExperiment.Exp1
{
    public class Main
    {
        public static void Run()
        {
            CentralProcessUnit.GenerateProcessList(5);
            new CentralProcessUnit().Run();
        }
    }
}

运行结果

  • 生成的process_list.txt内容:
0 1 8 3
1 2 3 1
2 4 8 0
3 8 6 3
4 16 4 1
  • 控制台输出

时间:1,运行进程 0
时间:2,运行进程 1
时间:3,运行进程 2
时间:4,运行进程 3
时间:5,运行进程 4
时间:6,运行进程 0
时间:7,运行进程 1
时间:8,运行进程 2
时间:9,进程 3 到达
时间:9,运行进程 3
时间:10,运行进程 4
时间:11,运行进程 0
时间:12,运行进程 1
时间:13,运行进程 2
时间:14,运行进程 3
时间:15,运行进程 4
时间:16,运行进程 0
时间:17,运行进程 1
时间:17,进程 1 运行完毕,总运行时间:3
时间:18,运行进程 2
时间:19,运行进程 3
时间:20,运行进程 4
时间:21,运行进程 0
时间:23,运行进程 2
时间:24,运行进程 3
时间:25,运行进程 4
时间:25,进程 4 运行完毕,总运行时间:4
时间:26,运行进程 0
时间:28,运行进程 2
时间:29,运行进程 3
时间:31,运行进程 0
时间:33,运行进程 2
时间:34,运行进程 3
时间:34,进程 3 运行完毕,总运行时间:6
时间:36,运行进程 0
时间:38,运行进程 2
时间:41,运行进程 0
时间:41,进程 0 运行完毕,总运行时间:8
时间:43,运行进程 2
时间:43,进程 2 运行完毕,总运行时间:8

About


了解更多有趣的操作请关注我的微信公众号:DealiAxy
每一篇文章都在我的博客有收录:blog.deali.cn

你可能感兴趣的

载入中...