【C#可视化|VS】操作系统简单轮转法程序模拟，基于Lsit操作

于 2022-12-01 22:11:12 发布
阅读量339 收藏 3
点赞数
分类专栏： C#语言 文章标签： c# visual studio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_66064881/article/details/127678774
版权

目录

 

实验课题：

实验代码（C#部分）：

实验数据样例选取：

实验预估流程展示：

实验思路：

数据封装及申明：

 界面初始化及清楚方块界面：

画面描绘（不变）：

画面描绘（可变+核心）：

主函数代码：

实验总代码（全）：

实验效果：

实验课题：

简单轮转调度：进程就绪队列按各进程进入的先后顺序排列。进程每次所需处理机的轮转式按其重要程度记入进程控制块中的轮转时间片数记录项。进程执行时，每运行一个时间片，进程还需要的时间片数减2，运行进程占用处理机的时间片数加2，然后比较占用CPU的时间片数是否与该进程的轮转时间片数相等，若相等则说明已达到轮转时间，应将现运行的进程排列就绪队列的末尾，调度队列上的首进程运行，且改变它们的进程状态，直至所有进程完成各自的时间片。

实验代码（C#部分）：

实验数据样例选取：

如下为进程进度(以时间片N为2)：（不想看的可以直达最后哦）

进程名

到达进程时间

运行时间

A

0

4

B

1

3

C

2

5

D

3

2

E

4

4

 实验的大致逻辑图

实验的效果是将根据从队列的头一个划分为一段时间片，再根据简单轮转....（无需考虑权重，从第一个转向最后一个，不累赘，都懂~打字太麻烦）。

初设步骤一

初设步骤二

实验预估流程展示：

调度1

调度2

调度3

调度4

调度5

调度6

调度7

调度8

调度9

调度10

A

2

2

2

2

2

4=4

B

0

2

2

2

2

2

3=3

C

0

0

2

2

2

2

2

4

4

5=5

D

0

0

0

2=2

E

0

0

0

0

2

2

2

2

4=4

实验思路：

C#原用List封装“A,B,C,D,E”多项元组，然后进程中再额外申明一个List来实现表达。

数据封装及申明：

申明E_nodeState的状态（等待，跑，完成）

  enum E_nodeState
    {
        wait,//等待
        runn,//跑
        finish,//完成时
    }

申明结点（名称，状态，需要运行时间，已运行时间，到达时间，有无进入进程，有无完成）

   class LinkNode
    {
       public string linkname;
        public E_nodeState state; //状态
       public  int ntime; //总需要运行时间
       public  int rtime; //已运行时间
       public  int arrivetime;//到达时间
        public bool isInserted;//记录有无进入进程
        public bool isCompleted;//记录有无运行完成

       public LinkNode(string linkname,int ntime)//结点初始化
       {
            this.linkname = linkname;
            this.state = E_nodeState.wait;
            this.ntime = ntime;
            this.rtime = 0;
            this.isInserted = false;
            this.isCompleted = false;
       }
        public LinkNode(string linkname, int ntime, int arrivetime) : this(linkname,ntime)//结点初始化
        {
            this.arrivetime = arrivetime;
        }

        public void GetRunTime(int value)//外部可得，后来想想可以放置为属性
        {
            this.rtime = value;
        }
       
        public void DisPlaying()//结点展示
        {
            Console.WriteLine(linkname + "       " + state + "       " + arrivetime+"       "+ntime + "        "+rtime);
        }

        private void ChooseColor(E_nodeState state)
        {
            switch (state)
            {
                case E_nodeState.wait:
                    Console.ForegroundColor = ConsoleColor.Blue;
                    break;
                case E_nodeState.runn:
                    Console.ForegroundColor = ConsoleColor.Yellow;
                    break;
                case E_nodeState.finish:
                    Console.ForegroundColor = ConsoleColor.Magenta;
                    break;
            }
        }
        public void DrawT(int width_index1,int _height)//结点绘制方块
        {
            Console.ForegroundColor = ConsoleColor.White;
            Console.SetCursorPosition(width_index1, _height - 12);
            Console.Write(this.linkname);

            for(int i = 0; i < this.rtime; i++)
            {
                Console.SetCursorPosition(width_index1, _height - 13-i);
                //Console.Write("  ");
                ChooseColor(this.state);
                Console.Write("■");
            }
        }

    }

 界面初始化及清楚方块界面：

 static void ConsoleInit(int _width, int _height)//基础设置
 {
   //光标隐藏
   Console.CursorVisible = false;
   //舞台大小
   Console.SetWindowSize(_width, _height);
   Console.SetBufferSize(_width, _height);
}
        
static void ClearT(int _width, int _height)
{
  for (int i = 1; i < _height - 11; i++)
  {
     Console.SetCursorPosition(2, i);
      Console.Write("                                       ");
  } 
}

画面描绘（不变）：

绘制墙体基础信息：

Console.ForegroundColor = ConsoleColor.Red;
for (int i = 0; i < _width; i += 2)//行绘制
{
   Console.SetCursorPosition(i, 0);
   Console.Write("■");
   Console.SetCursorPosition(i, _height - 10);
   Console.Write("■");
   Console.SetCursorPosition(i, _height - 1);
   Console.Write("■");
}
for (int i = 0; i < _height; i += 1)//列绘制
{
   Console.SetCursorPosition(0, i);
   Console.Write("■");
   Console.SetCursorPosition(_width - 2, i);
   Console.Write("■");
}

绘制基础文字信息：

int width_index = (_width - 4) / LInkList.Count - LInkList.Count / 2;
Console.ForegroundColor = ConsoleColor.Yellow;
Console.SetCursorPosition(width_index, _height - 11);
Console.Write("■"+"RUNNING" + "   ");
Console.ForegroundColor = ConsoleColor.Blue;
Console.Write("■" + "WAITING" + "   ");

Console.ForegroundColor = ConsoleColor.White;
Console.SetCursorPosition(width_index, _height - 9);//基础信息
Console.WriteLine("Pname" + "   " + "state" + "   " + "artime" + "   " + "ntime" + "    " + "rtime");

总代码：

  static void UnChangedeDraw(int _width, int _height, List<LinkNode> LInkList, List<LinkNode> InRunningList)//绘制墙体基础信息
        {
            Console.ForegroundColor = ConsoleColor.Red;
            for (int i = 0; i < _width; i += 2)
            {
                Console.SetCursorPosition(i, 0);
                Console.Write("■");
                Console.SetCursorPosition(i, _height - 10);
                Console.Write("■");
                Console.SetCursorPosition(i, _height - 1);
                Console.Write("■");
            }
            for (int i = 0; i < _height; i += 1)
            {
                Console.SetCursorPosition(0, i);
                Console.Write("■");
                Console.SetCursorPosition(_width - 2, i);
                Console.Write("■");
            }

            int width_index = (_width - 4) / LInkList.Count - LInkList.Count / 2;

            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.SetCursorPosition(width_index, _height - 11);
            Console.Write("■"+"RUNNING" + "   ");
            Console.ForegroundColor = ConsoleColor.Blue;
            Console.Write("■" + "WAITING" + "   ");
            //Console.ForegroundColor = ConsoleColor.Magenta;//这里偷懒了，懒得写Finished,有想写的友人可以尝试
            //Console.Write("■" + "FINISHED" );

            Console.ForegroundColor = ConsoleColor.White;
            Console.SetCursorPosition(width_index, _height - 9);//基础信息
            Console.WriteLine("Pname" + "   " + "state" + "   " + "artime" + "   " + "ntime" + "    " + "rtime");
           
        }

画面描绘（可变+核心）：

总代码：

 static void ChangedeDraw(int _width, int _height, List<LinkNode> LInkList, List<LinkNode> InRunningList)
{
    int NowIndexScence = 1;//第一次回合
    int N = 2;//时间片段
    bool isStartRotate = false;
    int InRunningListInsert=0;
    int POPindex = -1;
    string POPlinkname;

    #region 第一回合
    for (int index = 0; index < LInkList.Count; index++)
    {
        //到达时间到达0，未插入处理
        if (LInkList[index].arrivetime == 0&& LInkList[index].isInserted==false)
        {
        LInkList[index].isInserted =true;
        /****************将未进的新程序放入到 InRunningList**********************/
        LinkNode tempNode1 = new      
  LinkNode(LInkList[index].linkname,LInkList[index].ntime,LInkList[index].arrivetime);
        tempNode1.state = E_nodeState.runn;
        InRunningList.Add(tempNode1);

        InRunningListInsert++;
        }

        //每个回合减一
        LInkList[index].arrivetime--;
        if (LInkList[index].arrivetime < 0) LInkList[index].arrivetime = 0;
    }
   OUTPutLInkList(_width, _height, InRunningList, LInkList,NowIndexScence,POPindex, POPlinkname="");//定位，正在跑的进程，回合制,弹出判断
   #endregion


   while (true)
   {
      //回合进行时

     Console.ReadKey(true);//检测输入
     NowIndexScence++;//下一回合

     //**************************对于InRunningList处理(时间片N,限制边界)
     for (int index = 0; index < InRunningList.Count; index++)//对于InRunningList处理
      {
      //每回合读取一个时间片N
      if ((InRunningList[index].state == E_nodeState.runn) && (InRunningList[index].isCompleted == false))
      {
       InRunningList[index].rtime += N;
       }


       //限制边界
      if (InRunningList[index].rtime >= InRunningList[index].ntime)
      {
        InRunningList[index].rtime = InRunningList[index].ntime;
        InRunningList[index].isCompleted = true;
        InRunningList[index].state = E_nodeState.finish;

        POPindex = index;
        POPlinkname = InRunningList[index].linkname;              
      }               
   }
/*******************第一次轮转*********************************/

      if (InRunningListInsert == LInkList.Count) isStartRotate = true;
      //**************第一次轮转，uncompleted全部插入
     if (isStartRotate) {
     LinkNode tempNode1 = 
                        new LinkNode(InRunningList[InRunningList.Count-1].linkname, InRunningList[InRunningList.Count-1].ntime, InRunningList[InRunningList.Count-1].arrivetime);
     tempNode1.state = E_nodeState.runn;
     tempNode1.GetRunTime(InRunningList[InRunningList.Count - 1].rtime);


      InRunningList.Add(tempNode1);//扩容
      for (int index = InRunningList.Count-2; index>0; index--)//将第一个放置于最后，依次向上
      {
         InRunningList[index] = InRunningList[index-1];
         InRunningList[index].state = E_nodeState.wait;
       }
      InRunningList[0] = tempNode1;
       InRunningList.RemoveAt(InRunningList.Count-1);
      }

      //******************************对于LInkList处理(未进的新程序)
      for (int index = 0; index < LInkList.Count; index++)//对于LInkList处理
       {
       //到达时间到达0，未插入处理
      if (LInkList[index].arrivetime == 0 && LInkList[index].isInserted == false)
      {
        LInkList[index].isInserted = true;

       /***********将未进的新程序放入到 InRunningList************/
       LinkNode tempNode1 = new LinkNode(LInkList[index].linkname, LInkList[index].ntime, LInkList[index].arrivetime);
       tempNode1.state = E_nodeState.runn;
       InRunningList.Add(tempNode1);
       if (InRunningList.Count <= LInkList.Count)//判断有无剩余的完全插入？？
           {
           for (int i = InRunningList.Count - 1; i > 0; i--)
           {
             InRunningList[i] = InRunningList[i - 1];
             InRunningList[i].state = E_nodeState.wait;
           }
             InRunningList[0] = tempNode1;
          }
          InRunningListInsert++;
        }

           //每个回合减一
           LInkList[index].arrivetime--;
           if (LInkList[index].arrivetime < 0) LInkList[index].arrivetime = 0;
          }

         /**********************清除IsComplete***********************/
         for (int index = 0; index < InRunningList.Count; index++)//对于InRunningList处理,删除
          {
          if (InRunningList[index].isCompleted == true)
           {
            InRunningList.RemoveAt(index);
           }
          }
                OUTPutLInkList(_width, _height, InRunningList, LInkList,NowIndexScence, POPindex, POPlinkname);//定位，正在跑的进程，回合制,弹出判断

                POPindex = -1;
            }
            //Console.ReadKey(true);//检测输入
        }

附属代码：

 private static void OUTPutLInkList(int _width, int _height,List<LinkNode> InRunningList, List<LinkNode> LInkList, int NowIndex,int POPindex, string POPlinkname)
{
   #region 依次画出InRunningList的数值
    Console.ForegroundColor = ConsoleColor.White;
    int width_index = (_width - 4) / LInkList.Count - LInkList.Count / 2;
            
    for (int j = 0; j < InRunningList.Count; j++)
     {
       Console.SetCursorPosition(width_index, _height - 8 + j);
       InRunningList[j].DisPlaying();
       Console.SetCursorPosition(width_index, _height - 8 + j + 1);
       Console.Write("                                     ");
     }

       Console.SetCursorPosition(width_index, _height - 8 + LInkList.Count + 1);
       Console.Write("                                     ");
       Console.SetCursorPosition(width_index, _height - 8 + LInkList.Count + 1);
       Console.WriteLine("PROCESSING:" + NowIndex);

           
      if (POPindex != -1)
      { 
      Console.SetCursorPosition(_width/2, _height - 8 + LInkList.Count + 1);
      Console.WriteLine("FINISHED P:" + POPlinkname);
      }

      #endregion

      //***********************************?
      #region 可变方块测绘
      int width_index1 = (_width - 4) / LInkList.Count - LInkList.Count / 2;
      ClearT(_width, _height);
      for (int i = 0; i < InRunningList.Count; i++)
      {
      InRunningList[i].DrawT(width_index1, _height);
               
      width_index1 += (_width - 4) / LInkList.Count;
       }
      #endregion
            
 }

主函数代码：

 static void Main(string[] args)
 {
 // Console.WriteLine("Hello World!");
 /* LinkNode node1 = new LinkNode("A", 4, 0);
    LinkNode node2 = new LinkNode("B", 3, 1);
    LinkNode node3 = new LinkNode("C", 5, 2);
    LinkNode node4 = new LinkNode("D", 2, 3);
    LinkNode node5 = new LinkNode("E", 4, 4);*/
 /*********************初始化********************************/
int _width = 50; int _height = 30;
ConsoleInit(_width, _height);
List<LinkNode> LInkList =
new List<LinkNode> { { new LinkNode("A", 4, 0) }, { new LinkNode("B", 3, 1) },{ new LinkNode("C", 5, 2) }, new LinkNode("D", 2, 3),{ new LinkNode("E", 4, 4) } };
List<LinkNode> InRunningList = new List<LinkNode>();//进程进行列表


 while (true)
{
// LInkList[1].DisPlaying();
 UnChangedeDraw(_width, _height, LInkList, InRunningList);
ChangedeDraw(_width, _height, LInkList, InRunningList);
 }  
}

实验总代码（全）：

using System;
using System.Collections.Generic;

namespace JianDanLunZhuan
{
    enum E_nodeState
    {
        wait,
        runn,
        finish,
    }
    class LinkNode
    {
       public string linkname;
        public E_nodeState state; //状态
       //public  int super; //优先数
       public  int ntime; //总需要运行时间
       public  int rtime; //已运行时间
        //private int rtimeMax;
       //public  int wtime;//已等待时间
       public  int arrivetime;//到达时间
       //public int isAllRepeated;//记录轮转时间
       // public bool isAllRepeatedFlow;//记录轮转超标
        public bool isInserted;//记录有无进入进程
        public bool isCompleted;//记录有无运行完成

       public LinkNode(string linkname,int ntime)
       {
            this.linkname = linkname;
            this.state = E_nodeState.wait;
            //this.super = super;
            this.ntime = ntime;
            this.rtime = 0;
            //this.wtime = wtime;
           // this.isAllRepeated = 0;
            //this.isAllRepeatedFlow = false;
            this.isInserted = false;
            this.isCompleted = false;
       }
        public LinkNode(string linkname, int ntime, int arrivetime) : this(linkname,ntime)
        {
            this.arrivetime = arrivetime;
        }

        public void GetRunTime(int value)
        {
            this.rtime = value;
        }
       
        public void DisPlaying()
        {
            Console.WriteLine(linkname + "       " + state + "       " + arrivetime+"       "+ntime + "        "+rtime);
        }

        private void ChooseColor(E_nodeState state)
        {
            switch (state)
            {
                case E_nodeState.wait:
                    Console.ForegroundColor = ConsoleColor.Blue;
                    break;
                case E_nodeState.runn:
                    Console.ForegroundColor = ConsoleColor.Yellow;
                    break;
                case E_nodeState.finish:
                    Console.ForegroundColor = ConsoleColor.Magenta;
                    break;
            }
        }
        public void DrawT(int width_index1,int _height)
        {
            Console.ForegroundColor = ConsoleColor.White;
            Console.SetCursorPosition(width_index1, _height - 12);
            Console.Write(this.linkname);

            for(int i = 0; i < this.rtime; i++)
            {
                Console.SetCursorPosition(width_index1, _height - 13-i);
                //Console.Write("  ");
                ChooseColor(this.state);
                Console.Write("■");
            }
        }

    }

    class Program
    {
        static void Main(string[] args)
        {
            // Console.WriteLine("Hello World!");
            /* LinkNode node1 = new LinkNode("A", 4, 0);
             LinkNode node2 = new LinkNode("B", 3, 1);
             LinkNode node3 = new LinkNode("C", 5, 2);
             LinkNode node4 = new LinkNode("D", 2, 3);
             LinkNode node5 = new LinkNode("E", 4, 4);*/
            /*********************初始化********************************/
            int _width = 50; int _height = 30;
            ConsoleInit(_width, _height);
            List<LinkNode> LInkList =
                new List<LinkNode> { { new LinkNode("A", 4, 0) }, { new LinkNode("B", 3, 1) },{ new LinkNode("C", 5, 2) }, new LinkNode("D", 2, 3),
                { new LinkNode("E", 4, 4) } };
            List<LinkNode> InRunningList = new List<LinkNode>();//进程进行列表


            while (true)
            {
               // LInkList[1].DisPlaying();
                UnChangedeDraw(_width, _height, LInkList, InRunningList);
                ChangedeDraw(_width, _height, LInkList, InRunningList);
            }
        }
        static void ConsoleInit(int _width, int _height)//基础设置
        {
            //光标隐藏
            Console.CursorVisible = false;
            //舞台大小
            Console.SetWindowSize(_width, _height);
            Console.SetBufferSize(_width, _height);
        }
        
        static void ClearT(int _width, int _height)
        {
            for (int i = 1; i < _height - 11; i++)
            {
                Console.SetCursorPosition(2, i);
                Console.Write("                                       ");
            }
        }


        static void UnChangedeDraw(int _width, int _height, List<LinkNode> LInkList, List<LinkNode> InRunningList)
        {
            Console.ForegroundColor = ConsoleColor.Red;
            for (int i = 0; i < _width; i += 2)
            {
                Console.SetCursorPosition(i, 0);
                Console.Write("■");
                Console.SetCursorPosition(i, _height - 10);
                Console.Write("■");
                Console.SetCursorPosition(i, _height - 1);
                Console.Write("■");
            }
            for (int i = 0; i < _height; i += 1)
            {
                Console.SetCursorPosition(0, i);
                Console.Write("■");
                Console.SetCursorPosition(_width - 2, i);
                Console.Write("■");
            }

            int width_index = (_width - 4) / LInkList.Count - LInkList.Count / 2;

            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.SetCursorPosition(width_index, _height - 11);
            Console.Write("■"+"RUNNING" + "   ");
            Console.ForegroundColor = ConsoleColor.Blue;
            Console.Write("■" + "WAITING" + "   ");
            //Console.ForegroundColor = ConsoleColor.Magenta;
            //Console.Write("■" + "FINISHED" );

            Console.ForegroundColor = ConsoleColor.White;
            Console.SetCursorPosition(width_index, _height - 9);//基础信息
            Console.WriteLine("Pname" + "   " + "state" + "   " + "artime" + "   " + "ntime" + "    " + "rtime");
           
        }

        static void ChangedeDraw(int _width, int _height, List<LinkNode> LInkList, List<LinkNode> InRunningList)
        {
            //bool isOver = false;
            //int SumIndex = 0;
            int NowIndexScence = 1;//第一次回合
            int N = 2;//时间片段
            bool isStartRotate = false;
            int InRunningListInsert=0;
            int POPindex = -1;
            string POPlinkname;

            #region 第一回合
            for (int index = 0; index < LInkList.Count; index++)
            {
                //到达时间到达0，未插入处理
                if (LInkList[index].arrivetime == 0&& LInkList[index].isInserted==false)
                {
                  
                    LInkList[index].isInserted =true;


                    /****************将未进的新程序放入到 InRunningList**********************/
                    LinkNode tempNode1 = new LinkNode(LInkList[index].linkname,LInkList[index].ntime,LInkList[index].arrivetime);
                    tempNode1.state = E_nodeState.runn;
                    InRunningList.Add(tempNode1);

                    InRunningListInsert++;
                }

                //每个回合减一
                LInkList[index].arrivetime--;
                if (LInkList[index].arrivetime < 0) LInkList[index].arrivetime = 0;

            }
            OUTPutLInkList(_width, _height, InRunningList, LInkList,NowIndexScence,POPindex, POPlinkname="");//定位，正在跑的进程，回合制,弹出判断
            #endregion


            while (true)
            {
                //回合进行时

                Console.ReadKey(true);//检测输入
                NowIndexScence++;//下一回合

                //**************************对于InRunningList处理(时间片N,限制边界)
                for (int index = 0; index < InRunningList.Count; index++)//对于InRunningList处理
                {
                    //每回合读取一个时间片N
                    if ((InRunningList[index].state == E_nodeState.runn) && (InRunningList[index].isCompleted == false))
                    {
                        InRunningList[index].rtime += N;
                    }


                    //限制边界
                    if (InRunningList[index].rtime >= InRunningList[index].ntime)
                    {
                        InRunningList[index].rtime = InRunningList[index].ntime;
                        InRunningList[index].isCompleted = true;
                        InRunningList[index].state = E_nodeState.finish;

                        POPindex = index;
                        POPlinkname = InRunningList[index].linkname;
                       
                    }
                    
                }

                /******************************第一次轮转*****************************************************/

                if (InRunningListInsert == LInkList.Count) isStartRotate = true;
                //**************第一次轮转，uncompleted全部插入
               // bool isAllRotate = true;//??
                if (isStartRotate) {
                    LinkNode tempNode1 = 
                        new LinkNode(InRunningList[InRunningList.Count-1].linkname, InRunningList[InRunningList.Count-1].ntime, InRunningList[InRunningList.Count-1].arrivetime);
                    tempNode1.state = E_nodeState.runn;
                    tempNode1.GetRunTime(InRunningList[InRunningList.Count - 1].rtime);


                    InRunningList.Add(tempNode1);//扩容
                    for (int index = InRunningList.Count-2; index>0; index--)//将第一个放置于最后，依次向上
                    {
                        InRunningList[index] = InRunningList[index-1];
                        InRunningList[index].state = E_nodeState.wait;
                    }
                    InRunningList[0] = tempNode1;
                    InRunningList.RemoveAt(InRunningList.Count-1);
                }

                //******************************对于LInkList处理(未进的新程序)
                for (int index = 0; index < LInkList.Count; index++)//对于LInkList处理
                {
                    //到达时间到达0，未插入处理
                    if (LInkList[index].arrivetime == 0 && LInkList[index].isInserted == false)
                    {

                        LInkList[index].isInserted = true;

                        /****************将未进的新程序放入到 InRunningList**********************/
                        LinkNode tempNode1 = new LinkNode(LInkList[index].linkname, LInkList[index].ntime, LInkList[index].arrivetime);
                        tempNode1.state = E_nodeState.runn;
                        InRunningList.Add(tempNode1);
                        if (InRunningList.Count <= LInkList.Count)//判断有无剩余的完全插入？？
                        {
                            for (int i = InRunningList.Count - 1; i > 0; i--)
                            {
                                InRunningList[i] = InRunningList[i - 1];
                                InRunningList[i].state = E_nodeState.wait;
                            }
                            InRunningList[0] = tempNode1;
                        }
                        InRunningListInsert++;
                    }

                    //每个回合减一
                    LInkList[index].arrivetime--;
                    if (LInkList[index].arrivetime < 0) LInkList[index].arrivetime = 0;
                }

                /**********************清除IsComplete***********************/
                for (int index = 0; index < InRunningList.Count; index++)//对于InRunningList处理,删除
                {
                    if (InRunningList[index].isCompleted == true)
                    {
                        InRunningList.RemoveAt(index);
                    }
                }


                OUTPutLInkList(_width, _height, InRunningList, LInkList,NowIndexScence, POPindex, POPlinkname);//定位，正在跑的进程，回合制,弹出判断

                POPindex = -1;
            }
            //Console.ReadKey(true);//检测输入
        }

        private static void OUTPutLInkList(int _width, int _height,List<LinkNode> InRunningList, List<LinkNode> LInkList, int NowIndex,int POPindex, string POPlinkname)
        {
            #region 依次画出InRunningList的数值
            Console.ForegroundColor = ConsoleColor.White;
            int width_index = (_width - 4) / LInkList.Count - LInkList.Count / 2;
            
            for (int j = 0; j < InRunningList.Count; j++)
            {
                Console.SetCursorPosition(width_index, _height - 8 + j);
                InRunningList[j].DisPlaying();
                Console.SetCursorPosition(width_index, _height - 8 + j + 1);
                Console.Write("                                     ");
            }

            Console.SetCursorPosition(width_index, _height - 8 + LInkList.Count + 1);
            Console.Write("                                     ");
            Console.SetCursorPosition(width_index, _height - 8 + LInkList.Count + 1);
            Console.WriteLine("PROCESSING:" + NowIndex);

           
            if (POPindex != -1)
            { 
                Console.SetCursorPosition(_width/2, _height - 8 + LInkList.Count + 1);
                Console.WriteLine("FINISHED P:" + POPlinkname);
            }

            #endregion

            //***********************************?
            #region 可变方块测绘
            int width_index1 = (_width - 4) / LInkList.Count - LInkList.Count / 2;
            ClearT(_width, _height);
            for (int i = 0; i < InRunningList.Count; i++)
            {
                InRunningList[i].DrawT(width_index1, _height);
               
                width_index1 += (_width - 4) / LInkList.Count;
            }
            #endregion
            
        }
    }
}

实验效果：

小窝我的爱
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
操作系统课程设计--使用多线程模拟时间片轮转法调度
大白的博客
07-04 1389
本片博文分享操作系统课程设计–使用多线程模拟时间片轮转法调度算法 实验环境：ubuntu18.04 ，VS Code 1、题目： 设计一个按照时间片轮转法实现处理机调度的程序，时间片轮转法实现处理机调度的程序设计提示如下： （1） 假设系统有n个进程，每个进程用一个进程控制块（PCB）来代表。进程控制块的格式如下表所示，且参数意义也相同。 （2） 按照进程到达的先后顺序排成一个循环队列，设一个队首指针指向第一个到达进程的首址。另外再设一个当前运行进程指针，指向当前正运行的进程。 （3） 执行处理机调度时
进程调度C#源代码优先级加轮转
06-19
用C#实现进程调度，才用优先级加轮转算法，时间片为5
C#操作系统实验-搭建简单的交互式实验系统
wql1200的博客
05-18 917
操作系统实验报告 安徽师范大学 计算机与信息学院 姓名： XXX 学号： 1911130XXXX 年级专业： 软工二班 实 验 题 目： 搭建交互式实验系统 【1．需求分析】 本次实验的任务是搭建一个操作系统的辅助系统的框架，以便于后续实验进行（后续实验在此框架中运行实现）； （1）本次实验输入形式：字符串 输入值范围：合法字符； 输出形式：文件（菜单功能响应）； （2）展示的是一个操作系统辅助系统的菜单界面； ①生成“文件”菜单组，包含“打开”、“保存”、“退出”等（实现快捷键） ②生
C#实验报告4（含实验小结）
weixin_51330376的博客
10-16 1999
实验4
C#操作系统实验-进程状态转化实现
wql1200的博客
05-18 1860
操作系统实验报告 安徽师范大学 计算机与信息学院 姓名： XXX 学号： 1911130XXXX 年级专业： 软工二班 实 验 题 目： 实现进程状态转化 【1．需求分析】 利用高级语言编写程序，模拟进程状态转换的过程。 进程的主要状态：就绪、运行、阻塞、终止，状态之间的转换如下图所示: （1）输入形式：进程名、运行的时间片数、初始优先级且随时添加新进程。 （2）输出形式：实时输出进程转换的信息。 （3）程序功能：模拟进程状态转换过程。 【2．概要设计】 设计思路：采用可视化的集成开发环境 V
C#实验报告1:创建C#控制台应用程序和Windows窗体应用程序
weixin_51330376的博客
09-23 2835
C#入门作业
操作系统实验——可视化模拟
08-01
C#实现的对操作系统课程中经典算法的可视化模拟；如进程管理（进程状态转换、生产者-消费者、进程调度、银行家算法），存储管理（动态分区分配算法、分页算法），设备管理（磁盘调度算法）。 适宜人群：正在学习操作...
哲学家进餐问题【VS可视化；C#；操作系统作业】
10-08
在操作系统领域，C#可以用来编写控制并发行为的程序，虽然它不如C++或Java常见，但仍然能有效地解决哲学家进餐问题。 C#中实现并发控制的关键在于线程同步机制。在本案例中，可能使用了`Monitor`类，它是.NET框架...
广州大学操作系统课程设计——时间片轮转法.zip
07-15
在这个项目中，"C#版本（可视化）"很可能是一个使用C#编写的窗体应用程序，通过GUI展示时间片轮转法的过程，用户可以通过图形界面直观地看到进程调度的过程，这对于理解和学习操作系统原理非常有帮助。 另一方面，...
基于C#实现UWB三边测量定位模拟可视化系统毕业设计源码+数据.zip
10-22
基于C#实现UWB三边测量定位模拟可视化系统毕业设计源码+数据.zip 根据DW公司UWB上位机的算法用Unity3D做的三边测量定位算法可视化演示，这样可以让我们更直观的了解算法的可靠性！直接下载，导入Unity2019即可。 ...
操作系统实验之进程调度 （C#编写，GUI界面）
09-25
用C#编写的进程调度程序，包括优先权调度算法，时间片轮转法。能够显示每一步进程的变化情况。
操作系统课设（理发师问题，时间片轮转调度算法，优先数调度算法）c#,vs可视化）
11-15
我们将使用C#编程语言，并借助Visual Studio（VS）的可视化工具来实现这些算法。 首先，我们来看理发师问题。这是一个经典的哲学家就餐问题的变体，用于模拟并发控制的问题。在理发师店里，理发师自己也需要理发，...
先来先服务(FCFS)调度算法（Java实现）
热门推荐
世纪末的架构师的博客
05-17 1万+
文章目录前言一、先来先服务（FCFS）是什么？二、先来先服务（FCFS）算法分析三、实现代码1、作业数据类2、作业调度类3、运行结果总结 前言 在操作系统中作业调度的主要任务是根据PCB中的信息，检查系统中的资源能否满足作业对资源的需求，以及按照一定的调度算法从外存的后备队列中选取某些作业调入内存，并为它们创建进程、分配必要的资源。本文将以Java程序来实现先来先服务（FCFS）作业调度算法。 提示：以下是本篇文章正文内容，下面案例可供参考 一、先来先服务（FCFS）是什么？ FCFS是操作系统中最简单
C#版操作系统实验—CPU调度
giver
12-08 895
using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Threading.Tasks; using
[内附完整源码和文档] 基于C#的可视化进程调度算法
LEMFOooO的博客
08-02 996
一、目的要求 用C#语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解。 二、准备知识 2.1 基本概念 进程的概念 进程的状态和进程控制块 进程调度算法 2.2.2 进程的结构——PCB 进程都是由一系列操作(动作)所组成，通过这些操作来完成其任务。因此，不同的进程，其内部操作也不相同。在操作系统中，描述一个进程除了需要程序和私有数据之外，最主要的是需要一个与动态过程相联系的数据结构，该数据结构用来描述进程的外部特性(名字、状态等)以及与其它进程的联系(通信关系)等信息，该数据结构称为
基于C# winform的操作系统课程设计：SPOOLING假脱机输入输出技术模拟
KI的博客
12-09 6898
基于C# winform的操作系统课程设计：SPOOLING假脱机输入输出技术模拟
操作系统：进程调度模拟，C语言实现
weixin_45038876的博客
10-02 3845
作业要求 【题目要求】模拟实现进程调度的经典算法，包括FCFS、SJF（SPF）、HRRN和RR(时间片大小分别为1和4)。输出调度过程，并计算不同调度算法的周转时间、平均周转时间、带权周转时间、平均带权周转时间、等待时间、平均等待时间等信息。 【实习要求】 可选编程语言：C/C++/Java/C#/Python； 实现在同一个程序文件中（C/C++）； 请适当注释； 【实现提示】 可以用链式存储结构实现，推荐实现一个队列数组（queue array），该数组的每个元素都代表一个长度可变的队列，队列中的每个
操作系统进程调度算法实现
rj2017211811的博客
04-24 429
bug好多 #include<unistd.h> #include<stdio.h> #include<stdlib.h> //enum STATE{Ready,Running,Blocked}; #define MAX_SIZE 100 typedef struct process_pcb { //进程ID int ID;//process...
操作系统实验c#模拟进程的可执行程序
最新发布
12-19
操作系统实验C是指针对操作系统课程设计的一系列实验项目，旨在帮助学生加深对操作系统原理和概念的理解，并且通过实际操作加深对编程语言和系统调用的掌握。 在操作系统实验C中，学生需要完成一系列任务，比如设计...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值