操作系统实验：在linux下用c语言模拟进程调度算法程序

原创 已于 2025-08-13 23:04:33 修改 · 1.6k 阅读 · 14 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#linux #c语言 #算法
于 2024-11-15 22:25:12 首次发布

文章目录

1、实验内容

1）用C语言编程实现对N个进程采用某种进程调度算法（如动态优先权调度算法、先来先服务算法、短进程优先算法、时间片轮转调度算法）调度执行的模拟。

（2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段：
进程标识数ID。
进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。
进程已占用CPU时间CPUTIME。
进程还需占用的CPU时间ALLTIME。当进程运行完毕时，ALLTIME变为0。
进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，进程将进入阻塞状态。
进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME个时间片后，将转换成就绪状态。
进程状态STATE。
队列指针NEXT，用来将PCB排成队列。
（3）优先数改变的原则：
进程在就绪队列中呆一个时间片，优先数增加1。
进程每运行一个时间片，优先数减3。
（4）为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。
（5）分析程序运行的结果，谈一下自己的认识。

2、实验结果及分析

1、调度程序的运行实验结果截图
在这里插入图片描述
图1
在这里插入图片描述
图2
在这里插入图片描述
图3
分析：
图1和图2模拟了一个简单的进程调度过程，根据进程的优先级和运行时间来进行调度，直到所有进程运行完成。
具体而言，1、进程控制块（PCB）：定义了一个结构体 pcb 用来表示进程控制块，包括进程名、状态、优先级、需要运行时间、已经运行时间等信息。使用了 typedef 将 struct pcb 重命名为 PCB，提高代码可读性。
2、它其中有一个进程优先级排列函数sort（），对进程根据其优先级进行排序，以便按照优先级高低进行调度。使用的是插入排序的思想，根据进程的优先级将其插入到就绪队列中的适当位置。3、然后用户输入需要调度的进程数量以及每个进程的信息，包括进程名、优先级、需要运行时间等。每个进程被创建后，调用 sort() 函数将其按优先级插入到就绪队列中。
4、就绪队列长度计算函数 space()：返回当前就绪队列的长度。
5、进程显示函数 disp()：用于显示当前进程的信息。
6、进程查看函数 check()：显示当前正在运行的进程和就绪队列的状态。
7、进程撤消函数 destroy()：进程运行结束后调用，释放进程控制块占用的内存。
8、进程就绪函数 running()：进程运行时间到时，将进程状态置为就绪，更新其优先级，并重新排序就绪队列。
9、主函数 main()：调用 input() 函数创建进程。循环执行进程调度过程，直到所有进程都运行完成。在每次循环中，从就绪队列中取出一个进程进行运行，调用 check() 函数显示当前状态，然后调用 running() 函数执行进程，并等待用户按键继续。

图3
优先数法
进程就绪队列按优先数大小从高到低排列，链首进程首先投入运行。进程每执行一次，进程需要的时间片数减1、该进程的优先数减3。这样，该进程如果在一个时间片中没有完成，其优先数降低一级。接着仍是用该进程降低一级后的优先数与就绪队列中链首进程的优先数进行比较，如果仍是该进程的优先数高或相同，便让该进程继续执行；否则，调度就绪队列的链首进程投入运行。原运行过的进程按其现行优先数大小插入就绪队列，且改变它们对应的进程状态，一直到所有进程都运行完各自的时间片数。
(3) 时间轮转法
进程就绪队列按各进程进入的先后顺序排列。进程每次所需处理机的轮转式按其重要程度记入进程控制块中的轮转时间片数记录项。进程执行时，每运行一个时间片，进程还需要的时间片数减1，运行进程占用处理机的时间片数加1，然后比较占用CPU的时间片数是否与该进程的轮转时间片数相等，若相等则说明已达到轮转时间，应将现运行的进程排列就绪队列的末尾，调度队列上的首进程运行，且改变它们的进程状态，直至所有进程完成各自的时间片。
————————————————
来自这篇文章
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

原文链接：https://blog.csdn.net/g15827636417/article/details/53365903

在这里插入图片描述

在这里插入图片描述

3、如何在linux下编写并执行c语言程序以及实验源代码

1，使用vim编辑器编写程序，可在终端输入命令：sudo apt-get install vim 下载最新vim
在这里插入图片描述

2，需要下载c语言的编译器gcc，在终端输入命令：sudo apt-get install gcc 下载gcc

在这里插入图片描述
3，使用vi非常的简单，命令 # vi filename ，即可打开filename的文件，如果filename不存在则会新建一个。这里我们输入命令 ：
vi test.c
在这里插入图片描述
4，我们进入文件后，这是一般模式，你还不能输入任何字符，键入字符 i，，左下角显示 插入模式，表示我们进入了编辑模式，这时可以直接敲代码了。

敲好源程序后，我们先按 Esc 键退出编辑模式，再输 shift+： 键进入命令行模式，左下角出现 ：号，我们输入 wq，表示 保存并退出 ；再按Enter键即可。
在这里插入图片描述
我们又来到了终端界面，这时候有了源文件，我们来编译，命令如下：

gcc -o test test.c

成功后，我们查看当前目录下出现一个名为test 的可执行文件，

接着执行，通过命令# ./test 即可执行 ！
在这里插入图片描述
该部分来源此文章
源代码
代码一

#include "stdio.h" 
#include <stdlib.h> 
#define getpch(type) (type*)malloc(sizeof(type)) 

struct pcb { /* 定义进程控制块PCB */ 
  char name[10]; //进程名
  char state;    //进程状态："W"-就绪态，"R"-运行态
  int nice;      //进程优先级
  int ntime;     //需要运行时间
  int rtime;     //已经运行的时间
  struct pcb* link; 
}*ready=NULL,*p; 
typedef struct pcb PCB; 

char sort() /* 建立对进程进行优先级排列函数，优先数大者优先*/ 
{ 
  PCB *first, *second; 
  int insert=0; 
  if((ready==NULL)||((p->nice)>(ready->nice)))/*优先级最大者,插入队首*/ 
  { 
    p->link=ready; 
    ready=p; 
  } 
  else /* 进程比较优先级,插入适当的位置中*/ 
  { 
    first=ready; 
    second=first->link; 
    while(second!=NULL) 
    { 
      if((p->nice)>(second->nice)) /*若插入进程比当前进程优先数大,*/ 
      { /*插入到当前进程前面*/ 
        p->link=second; 
        first->link=p; 
        second=NULL; 
        insert=1; 
      } 
      else /* 插入进程优先数最低,则插入到队尾*/ 
      { 
        first=first->link; 
        second=second->link; 
      } 
    } 
    if(insert==0) first->link=p; 
  } 
} 

char input() /* 建立进程控制块函数*/ 
{ 
  int i,num; 
  printf("\n 请输入被调度的进程数目："); 
  scanf("%d",&num); 
  for(i=0;i<num;i++) 
  { 
    printf("\n 进程号No.%d:",i); 
    p=getpch(PCB); 
    printf("\n 输入进程名:"); 
    scanf("%s",p->name); 
    printf(" 输入进程优先数:"); 
    scanf("%d",&p->nice); 
    printf(" 输入进程运行时间:"); 
    scanf("%d",&p->ntime); 
    printf("\n"); 
    p->rtime=0;
    p->state='W'; 
    p->link=NULL; 
    sort(); /* 调用sort函数*/ 
  } 
} 

int space() 
{ 
  int l=0; PCB* pr=ready; 
  while(pr!=NULL) 
  { 
    l++; 
    pr=pr->link; 
  } 
  return(l); 
} 

char disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/ 
{ 
  printf("\n qname \t state \t nice \tndtime\truntime \n"); 
  printf("%s\t",pr->name); 
  printf("%c\t",pr->state); 
  printf("%d\t",pr->nice); 
  printf("%d\t",pr->ntime); 
  printf("%d\t",pr->rtime); 
  printf("\n"); 
}

char check() /* 建立进程查看函数 */ 
{ 
  PCB* pr; 
  printf("\n **** 当前正在运行的进程是:%s",p->name); /*显示当前运行进程*/ 
  disp(p); 
  pr=ready; 
  if (pr!=NULL) 
    printf("\n ****当前就绪队列状态为:"); /*显示就绪队列状态*/
  else 
    printf("\n ****当前就绪队列状态为: 空\n"); /*显示就绪队列状态为空*/
  while(pr!=NULL) 
  { 
    disp(pr); 
    pr=pr->link; 
  } 
} 

char destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/ 
{ 
  printf(" 进程 [%s] 已完成.\n",p->name); 
  free(p); 
}
 
char running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/ 
{ 
  (p->rtime)++; 
  if(p->rtime==p->ntime) 
  destroy(); /* 调用destroy函数*/ 
  else 
  { 
    (p->nice)--; 
    p->state='W'; 
    sort(); /*调用sort函数*/ 
  } 
} 

int main() /*主函数*/ 
{ 
  int len,h=0; 
  char ch; 
  input(); 
  len=space(); 
  while((len!=0)&&(ready!=NULL)) 
  { 
    ch=getchar(); 
    h++; 
    printf("\n The execute number:%d \n",h); 
    p=ready; 
    ready=p->link; 
    p->link=NULL; 
    p->state='R'; 
    check(); 
    running(); 
    printf("\n按任一键继续......"); 
    ch=getchar(); 
  } 
  printf("\n\n 所有进程已经运行完成！\n"); 
  ch=getchar(); 
}

代码二：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<stdbool.h>

typedef struct node{
  char name[10];
  int prio;
  int round;
  int cputime;
  int needtime;
  int count;
  char state;
  struct node *next;
}PCB;

PCB *finish,*ready,*run,*r;
int N;

void firstin()
{
  run = ready;
  run->state = 'R';
  ready = ready->next;
}
   
void prt1(char a)
{
  if(a=='P'||a == 'p') 
    printf("进程号  cpu时间   所需时间  优先数   状态\n");
  else if(a =='r'||a =='R')
    printf("进程号  cpu时间   所需时间   记数   时间片   状态\n");
  else if(a=='f'||a=='F')
    printf("进程号   所需时间   状态\n");
}

void prt2(char a ,PCB *q)
{
     if(a=='P'||a == 'p')
     printf("%-10s%-10d%-10d%-10d%c\n",q->name,q->cputime,q->needtime,q->prio,q->state);
     else if(a == 'r'|| a == 'R')
     printf("%-10s%-10d%-10d%-10d%-10d%c\n",q->name,q->cputime,q->needtime,q->count,q->round,q->state);
     else if(a=='f'||a=='F')
     printf("%-10s%-10d%c\n",q->name,q->needtime,q->state);
}

void prt(char algo)
{
     PCB *p;
     prt1(algo);
     if(run != NULL&& !(algo == 'r'||algo  =='R'))//这个对RR不适应！！ 
         prt2(algo,run);
     p = ready;
     while(p != NULL)
     {
         prt2(algo,p);
         p = p->next;
     }
     p = finish;
     while(p != NULL)
     {
         prt2(algo,p);
         p = p->next;
     }
     getchar();
}

void insert1(PCB *q)
{
   PCB *p1,*s,*r;
   int b;
   s = q;
   p1 = ready;
   r = p1;
   b = 1;
   while((p1 != NULL)&&b)
    {
       if(p1->prio >= s->prio)
       {
         r = p1;
         p1 = p1->next;
       }
       else b = 0;
    }
    if(r!= p1)
    {
      r->next = s;
      s->next = p1;
    }
    else
    {
      s->next = p1;
      ready = s;
    }
}

void creat1(char alg)
{
     PCB *p;
     int i,time;
     char na[10];
     ready = NULL;
     finish = NULL;
     run = NULL;
     printf("输入进程号和运行时间:\n");
     for(i = 1; i <= N; i++)
     {
       p = (PCB *)malloc(sizeof(PCB));
       scanf("%s",na);
       scanf("%d",&time);
       strcpy(p->name,na);
       p->cputime = 0;
       p->needtime = time;
       p->state = 'W';
       p->prio = 50-time;
       if(ready != NULL)
       insert1(p);
       else{
         p->next = ready;
         ready = p;
         }
     }
     //clrscr();
     if(alg =='p'||alg =='P')
       printf("   优先数算法输出信息:\n");
     else
       printf("   先来先服务算法输出信息:\n");
     printf("*****************************************\n");
     prt(alg);
     run = ready;
     ready = ready->next;
     run->state = 'R';
}

void creat2(char alg)
{
     PCB *p;
     int i,time,round;
     char na[10];
     ready = NULL;
     finish = NULL;
     run = NULL;
     printf("请输入时间片：");
     scanf("%d",&round);
     printf("输入进程号和运行时间:\n");
     for(i = 1; i <= N; i++)
     {
       p = (PCB *)malloc(sizeof(PCB));
       scanf("%s",na);
       scanf("%d",&time);
       strcpy(p->name,na);
       p->cputime = 0;
       p->needtime = time;
       p->state = 'W';
       p->count  = 0;
       p->round  = round;
       p->next = NULL;
        if(i == 1)/*按顺序插入到ready链表中*/
       r = ready = p;
       else
       r->next = p;
       r = p;  
     }
     //clrscr();
     printf("     时间片轮转算法输出信息:\n");
     printf("*****************************************\n");
     prt(alg);
}

void priority(char alg)  //优先数调度算法
{
     while(run != NULL)
     {
       run->cputime += 1;
       run->needtime -= 1;
       run->prio -= 3;
       if(run->needtime == 0)
        {
          run->next = finish;
          finish = run;
          run->state = 'F';
          run = NULL;
          if(ready != NULL)
          firstin();
        }
        else 
         if((ready != NULL) && (run->prio < ready->prio))
         {
            run->state = 'W';
            insert1(run);
            firstin();
         }
         prt(alg);
     }
}

void roundrun(char alg)  //时间片轮转调度算法
{
  bool flag;//当ready列里只有一个时做标记 
  while(N){
    flag = 1;//初始化为1 
    run = ready;//run每次运行ready的队头 
    run->count++;//每运行一次计数器加1 
    if(run->needtime < run->round)//当剩余时间小于时间片轮转时间时的情况 
            {
              run->cputime += run->needtime;
              run->needtime = 0;
            }
            else{
              run->cputime += run->round;
              run->needtime -= run->round;  
                }
         run->state = 'W';//变为等待 
        if(ready->next != NULL)
        ready = ready->next;
        else  flag = 0;//当ready剩一个时做标记 
        if(run->needtime == 0){//当run结束时放入finish队列里 
          run->next = finish;
          finish = run;
          run->state = 'F';
          N--;//进程数少1 
          }
          else{
          if(flag){//执行完如果不是剩一个的话，就把run放到队尾 
           r->next = run;
           r = run;
           r->next = NULL; 
                 }
              }
           if(N)ready->state = 'R';//结束时不应该有'R" 
           else
           ready = NULL;//结束时应该为空 
           prt(alg);//输出 
    }
}

void FCFSrun(char alg)  //先来先服务调度算法
{  
  PCB *p;
  while(run!=NULL)
  {
    run->cputime += run->needtime;
    run->needtime =0;               
    run->next = finish;
    finish = run;
    run->state = 'F';
    run = NULL;
    if(ready!=NULL)
      firstin();
      prt(alg);
    }
  }

int main()
{
      char algo;
      //clrscr();
      printf("选择算法:P/R/F(优先数算法/时间片轮转算法/先来先服务算法)\n");
      scanf("%c",&algo);
      printf("输入进程数:\n");
      scanf("%d",&N);
      if(algo == 'P'||algo == 'p')
      {
        creat1(algo);
        priority(algo);
      }
      else if(algo == 'R'||algo == 'r')
      {
        creat2(algo);
        roundrun(algo);
      }
      else if(algo=='f'||algo=='F')
      {
         creat1(algo);
         FCFSrun(algo);     
      }
     system("echo 按任意键退出");
     system("read -n 1");
     return 0;
}
C语言实现-操作系统实验-作业（进程）调度.docx
12-06
C语言实现-操作系统实验-作业（进程）调度.docx
【进程调度模拟】Linux “操作系统进程调度算法模拟：时间片轮转、优先级调度与先来先服务“
她是不会无条件的！！
10-22 2479
实验二 进程调度模拟
操作系统：进程调度实验(c语言)
weixin_44943308的博客
05-08 1253
#include <stdio.h> #include <stdlib.h> #define True 1 #define False 0 #define Q 1 //定义 PCB 的数据结构 typedef struct pcb{ unsigned char pid; //进程 id 号 unsigned char startTime; //开始时间 unsigned char serviceTime; //服务时间 unsigned char runn.
操作系统——四种进程调度算法模拟实现（C语言）
热门推荐
mcr1379673758的博客
05-03 6万+
操作系统——四种进程调度算法模拟实现（C语言）
【操作系统】【C语言】：C语言实现进程调度
qq_53690996的博客
01-04 8072
其中包含两个带头结点的链表表示的队列分别为就绪队列和阻塞队列，首先创建就绪队列ready和阻塞队列block，创建一个后期循环调度需要用到的中间进程队列end，首先循环遍历进程队列中各个进程结点，将进程状态为就绪的进程结点插入就绪队列中，将进程状态为阻塞的进程结点插入阻塞队列中。输入进程数为3，第一个进程的进程ID为1，优先数为3，需要运行的时间为4，时间2之后进入阻塞，阻塞时间为2，第二个进程进程ID为2，优先数为1，需要运行的时间为3，创建相应的就绪队列和阻塞队列的头节点解决了此问题。
实验：进程调度算法(C语言)
qq_44833321的博客
02-17 1万+
实验：进程调度算法 一、实验目的 1．实现四种不同及进程调度算法： 先来先服务、时间片轮转调、优先级调度以及短作业优先调度算法。 2．通过实验理解有关进程控制块，进程队列等的概念。 二、实验要求 1.运行素材中的代码，观察其执行结果是否正确？各个调度算法的功能是否完善？如果没有，则完善。 2. 按照下表输入3个作业信息，输出使用不同调度算法的结果。 3. 在现有三个调度算法的基础上，进一步实现短作业优先调度 ProcessID arrivetime servicetime priority
操作系统实验报告
weixin_43752106的博客
01-06 1万+
一、实验一 通过 VMware 虚拟机软件安装 Linux 二、实验目的 （1）学会安装 VMware 虚拟机软件并掌握其使用方法。 （2）学会使用 VMware 虚拟机安装 Linux 操作系统 （3）熟悉 Linux 下的 C/C++编程环境：vi/gedit 编辑器 + gcc 编译器 +gdb 调试器。 三、实验内容（实验原理/运用的理论知识、算法/程序流程图、步骤和方法、关键源代码） 1）安装 VMware workstation 虚拟机软件并新建一个虚拟机 2）使用 VMware 虚拟机安装 L
时间片轮转调度算法模拟（Linux-C语言）
qq_40633659的博客
01-06 4765
时间片轮转调度算法模拟 1. 实验目的 了解时间片轮转调度算法的工作原理，通过编写调度算法的程序，加深对Linux进程时间片调度的理解。 2. 实验内容 在Linux上编写C语言，实现从键盘输入时间片长度、任务个数、每一个任务的到达时间及服务时间； 构造相应的进程并按时间片轮转调度算法对所有进程进行调度，进程运行情况可以输出到终端，从而深入理解时间片轮转调度算法的原理。 2.1 程序流程图 ​ 程序中就绪队列用int型的数组表示，并用readyIndex表示下一个要插入就绪队列的位置，该数
操作系统实验报告之Linux系统下进程的创建与调度
qq_52052302的博客
08-15 4635
实验一 Linux系统中进程的创建与调度算法模拟实验
Linux编程：模拟进程调度算法
考拉研究僧的博客
12-10 8767
稍稍有点操作系统基础的朋友应该知道进程的调度算法，在这里Koala还是给大家略微介绍一下接下来将要用到的几种算法： 先来先服务（FCFS） 采用FCFS调度，先请求CPU的进程会先分配到CPU。 使用FCFS调度的等待时间通常较长，CPU利用率也会较低 最短作业优先调度（SJF） 采用SJF调度会选择具有最短CPU运行时间的进程分配CPU使用权。如果两个进程的CPU区间相同，则按照FCFS来进
操作系统课程设计进程调度模拟
m0_56241309的博客
11-10 4590
进程调度模拟
操作系统实验——磁盘调度算法
qq_45907357的博客
11-09 8818
文章目录前言一、实验目的二、实验内容和要求三、实验程序四、运行结果运行结果截图五、思考和分析程序实现(思路)：分析几种算法：附 前言 提示：本次实验在Linux(Ubuntu)中运行，程序中读取的文件需放在与c文件同一个文件夹中，或者自行在代码中修改路径。 一、实验目的 掌握几种基本的磁盘调度算法。 先来先服务法 最短寻道时间优先法 电梯法 二、实验内容和要求 采用模拟先来先服务法（First-Come, First-Served，FCFS），最短寻道时间优先法（Shortest Seek Time
希冀 操作系统 实验二 进程调度
m0_74172897的博客
10-29 5058
希冀 操作系统 实验二 进程调度 补全答案
【操作系统--CPU调度算法】Linux环境中C语言详解（附代码）
CSDN已停更，感兴趣关注https://aaronzijingcai.github.io/
12-22 1万+
操作系统之CPU调度算法，使用C语言实现，可运行在linux环境中
模拟进程调度程序
最新发布
只有我们在下潜
11-09 1900
只是在一定程度上模拟实现了这四种调度策略 (/ω＼)()╰(°▽°。
Java~操作系统实验按优先数调度算法实现处理器调度
2401_85836012的博客
08-13 539
状态——可假设有两种状态，“就绪”状态和“结束”状态。五个进程的初始状态都为“就绪”，用“R”表示，当一个进程运行结束后，它的状态为“结束”，用“E”表示。(8) 为五个进程任意确定一组“优先数”和“要求运行时间”，启动所设计的处理器调度程序，显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程。指针——按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程中的指针为“0”。其中，进程名——作为进程的标识，假设五个进程的进程名分别为P1，P2，P3，P4，P5。
计算机操作系统实验-进程调度模拟算法
y0205yang的博客
04-17 2242
在轮转法中，采用固定时间片单位（两个时间片为一个单位），进程每轮转一次，CPU时间片数加 2，进程还需要的时间片数减 2，并退出 CPU，排到就绪队列尾，等待下一次调度。进程名、进程优先数（或轮转时间片数）、进程已占用的 CPU 时间、进程到完成还需要的时间、进程的状态、当前队列指针等。2.各进程的优先数或轮转时间片数，以及进程运行时间片数的初值，均由用户在程序运行时给定。（2）INSERT2——在轮转法中，将执行了一个时间片单位（为 2），但尚未完成的进程。（6）PRISCH——按优先数算法调度进程；
操作系统实验——进程调度算法的模拟
m0_63646473的博客
05-15 3956
本程序是实现操作系统中进程调度的模拟实验，使用两种调度方法：先来先服务方法和短作业优先方法。
操作系统课程设计——进程调度（附c++代码）
qq_34066926的博客
07-03 3917
进程调度是操作系统中的一项关键功能，负责决定在什么时间由哪个进程使用CPU。调度的目标是提高系统效率和用户满意度。在本次课程设计中，涉及三种典型进程调度算法：非抢占短进程优先（NPSPP）算法、可抢占优先权调度（PPSA）算法以及多级反馈队列（MLFQ）调度算法。
实验1 进程调度（C）
HYK_DJ5201314的博客
05-11 4570
实验1 进程调度（C） 1．目的和要求 进程调度是处理机管理的核心内容。本实验要求用C语言编写和调试一个简单的进程调度程序。通过本实验可以加深理解有关进程控制块、进程队列的概念，并体会和了解优先数和时间片轮转调度算法的具体实施办法。 2．实验内容 ①设计进程控制块PCB表结构，分别适用于优先数调度算法和循环轮转调度算法。 ②建立进程就绪队列。对两种不同算法编制入链子程序。 ③编制两种进程调度算法：1）优先数调度；2）循环轮转调度 3）先来先服务调度 3．实验环境 ①PC兼容机 ②Windows、DOS系统、
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Unicornlyy

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值