进程调度算法

最新推荐文章于 2022-05-11 16:43:02 发布
最新推荐文章于 2022-05-11 16:43:02 发布
阅读量1.4k 收藏 16
点赞数 2
分类专栏： 操作系统课程设计 文章标签： 操作系统 进程调度算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42089175/article/details/89961405
版权

需求分析

分别实现先到先服务调度(FCFS)、最短作业优先调度(SJF)、高响应比优先调度、（抢占式）优先权调度和时间片轮转调度五种进程调度算法。

概要设计

1.先到先服务调度(FCFS)

  按照进程的到来顺序运行，先来的进程先服务，后到的进程后服务。

2.最短作业优先调度(SJF)

  按照作业的长短即要求服务时间运行，短作业优先服务。

3.高响应比优先调度(HRRN)

  每个进程在每个时刻都有一个响应比，按照响应比决定服务顺序。

4.（抢占式）优先权调度

  每个进程都有一个优先权重，进程按照优先权重抢占式获得CPU服务。

5.时间片轮转调度(RR)

  每个进程固定运行一个时间片的长度后让出处理机，让其他进程获得服务。

设计思想

   以结构体保存每个进程的包括开始时间、运行时间、结束时间、周转时间的所有信息，运用队列或优先队列模拟等待队列，运用某些算法动态的改变等待队列的进程排列实现以上五种进程调度算法。

代码实现

1.先到先服务调度(FCFS)

#include <bits/stdc++.h>

using namespace std;

const int maxn=1010;

struct node{

string pname;

double arrivetime;

double servetime;

double starttime;

double endtime;

double cycletime;

double withheightcycletime;

}process[maxn];

bool cmp(const node &a,const node &b)
{
    return a.arrivetime<b.arrivetime;
}
void run(int n)
{
    for(int i=1;i<=n;i++)
    {
        if(i==1)
        {
            process[i].starttime=process[i].arrivetime;
            process[i].endtime=process[i].starttime+process[i].servetime;
            process[i].cycletime=process[i].endtime-process[i].arrivetime;
            process[i].withheightcycletime=process[i].cycletime/process[i].servetime;
        }
        else
        {
            process[i].starttime=process[i-1].endtime;
            process[i].endtime=process[i].starttime+process[i].servetime;
            process[i].cycletime=process[i].endtime-process[i].arrivetime;
            process[i].withheightcycletime=process[i].cycletime/process[i].servetime;
        }
    }
}

void input(int n)
{

   for(int i=1;i<=n;i++)
   {
       cout<<"请输入第"<<i<<"个进程的名称、到达时间和服务时间"<<endl;
       cin>>process[i].pname>>process[i].arrivetime>>process[i].servetime;
       process[i].cycletime=0;
       process[i].endtime;
       process[i].starttime;
       process[i].withheightcycletime;
   }
}
void print(int n)
{
    cout<<"进程执行顺序"<<endl;
    for(int i=1;i<=n;i++)
        {
            if(i==1)
                cout<<process[i].pname;
            else
                cout<<"->"<<process[i].pname;
        }
    cout<<endl;
    cout<<"进程名称\t"<<"到达时间\t"<<"服务时间\t"<<"开始时间\t"<<"结束时间\t"<<"周转时间\t"<<"带权周转时间\t"<<endl;
    for(int i=1;i<=n;i++)
    {
        cout<<setiosflags(ios::fixed)<<setprecision(2)<<setw(8)<<process[i].pname<<"\t"<<setw(8)<<process[i].arrivetime<<"\t"<<setw(8)<<process[i].servetime<<"\t"<<setw(8)<<process[i].starttime<<"\t"<<setw(8)<<process[i].endtime<<"\t"<<setw(8)<<process[i].cycletime<<"\t"<<setw(12)<<process[i].withheightcycletime<<endl;
    }
}
void FCFS_PRO()
{
   cout<<"请输入进程的数量"<<endl;
   int n;
   cin>>n;
   input(n);
   sort(process+1,process+n+1,cmp);
   run(n);
   print(n);
}

int main()
{
   FCFS_PRO();
   return 0;
}
//5
//A 0 4
//B 1 3
//C 2 5
//D 3 2
//E 4 4

2.最短作业优先调度(SJF)

#include <bits/stdc++.h>

using namespace std;

const int maxn=1010;

struct node{

string pname;

double arrivetime;

double servetime;

double starttime;

double endtime;

double cycletime;

double withheightcycletime;

}process[maxn];

bool cmp(const node &a,const node &b)
{
    if(a.arrivetime!=b.arrivetime)
        return a.arrivetime<b.arrivetime;
    else
        return a.servetime<b.servetime;
}
bool servetimecmp(const node &a,const node &b)
{
    return a.servetime<b.servetime;
}
void run(int n)
{
    for(int i=1;i<=n;i++)
    {
        if(i==1)
        {
            process[i].starttime=process[i].arrivetime;
            process[i].endtime=process[i].starttime+process[i].servetime;
            process[i].cycletime=process[i].endtime-process[i].arrivetime;
            process[i].withheightcycletime=process[i].cycletime/process[i].servetime;
        }
        else
        {
            double time=process[i-1].endtime;
            int j;
            for(j=i;j<=n;)
                if(process[j].arrivetime<=time)
                   j++;
            sort(process+i,process+j,servetimecmp);
            process[i].starttime=process[i-1].endtime;
            process[i].endtime=process[i].starttime+process[i].servetime;
            process[i].cycletime=process[i].endtime-process[i].arrivetime;
            process[i].withheightcycletime=process[i].cycletime/process[i].servetime;
        }
    }
}

void input(int n)
{

   for(int i=1;i<=n;i++)
   {
       cout<<"请输入第"<<i<<"个进程的名称、到达时间和服务时间"<<endl;
       cin>>process[i].pname>>process[i].arrivetime>>process[i].servetime;
       process[i].cycletime=0;
       process[i].endtime;
       process[i].starttime;
       process[i].withheightcycletime;
   }
}
void print(int n)
{
    cout<<"进程执行顺序"<<endl;
    for(int i=1;i<=n;i++)
        {
            if(i==1)
                cout<<process[i].pname;
            else
                cout<<"->"<<process[i].pname;
        }
    cout<<endl;
    cout<<"进程名称\t"<<"到达时间\t"<<"服务时间\t"<<"开始时间\t"<<"结束时间\t"<<"周转时间\t"<<"带权周转时间\t"<<endl;
    for(int i=1;i<=n;i++)
    {
        cout<<setiosflags(ios::fixed)<<setprecision(2)<<setw(8)<<process[i].pname<<"\t"<<setw(8)<<process[i].arrivetime<<"\t"<<setw(8)<<process[i].servetime<<"\t"<<setw(8)<<process[i].starttime<<"\t"<<setw(8)<<process[i].endtime<<"\t"<<setw(8)<<process[i].cycletime<<"\t"<<setw(12)<<process[i].withheightcycletime<<endl;
    }
}
void SJF_PRO()
{
   cout<<"请输入进程的数量"<<endl;
   int n;
   cin>>n;
   input(n);
   sort(process+1,process+n+1,cmp);
   run(n);
   print(n);
}

int main()
{
   SJF_PRO();
   return 0;
}

3.高响应比优先调度(HRRN)

#include <bits/stdc++.h>

using namespace std;

const int maxn=1010;

struct node{

string pname;

double arrivetime;

double servetime;

double starttime;

double endtime;

double cycletime;

double withheightcycletime;

double priority;

}process[maxn];

bool cmp(const node &a,const node &b)
{
    if(a.arrivetime!=b.arrivetime)
        return a.arrivetime<b.arrivetime;
    else
        return a.servetime<b.servetime;
}
bool responsecmp(const node &a,const node &b)
{
    return a.priority>b.priority;
}
void run(int n)
{
    for(int i=1;i<=n;i++)
    {
        if(i==1)
        {
            process[i].starttime=process[i].arrivetime;
            process[i].endtime=process[i].starttime+process[i].servetime;
            process[i].cycletime=process[i].endtime-process[i].arrivetime;
            process[i].withheightcycletime=process[i].cycletime/process[i].servetime;


        }
        else
        {
            double time=process[i-1].endtime;
            for(int j=i;j<=n;j++)
            {
                process[j].priority=(time-process[j].arrivetime+process[j].servetime)/process[j].servetime;
                if(process[j].priority<1)
                process[j].priority=1;
            }
            sort(process+i,process+n+1,responsecmp);
            process[i].starttime=process[i-1].endtime;
            process[i].endtime=process[i].starttime+process[i].servetime;
            process[i].cycletime=process[i].endtime-process[i].arrivetime;
            process[i].withheightcycletime=process[i].cycletime/process[i].servetime;
        }
    }
}

void input(int n)
{

   for(int i=1;i<=n;i++)
   {
       cout<<"请输入第"<<i<<"个进程的名称、到达时间和服务时间"<<endl;
       cin>>process[i].pname>>process[i].arrivetime>>process[i].servetime;
       process[i].cycletime=0;
       process[i].endtime;
       process[i].starttime;
       process[i].withheightcycletime;
       process[i].priority=1;
   }
}
void print(int n)
{
    cout<<"进程执行顺序"<<endl;
    for(int i=1;i<=n;i++)
        {
            if(i==1)
                cout<<process[i].pname;
            else
                cout<<"->"<<process[i].pname;
        }
    cout<<endl;
    cout<<"进程名称\t"<<"到达时间\t"<<"服务时间\t"<<"开始时间\t"<<"结束时间\t"<<"周转时间\t"<<"带权周转时间\t"<<endl;
    for(int i=1;i<=n;i++)
    {
        cout<<setiosflags(ios::fixed)<<setprecision(2)<<setw(8)<<process[i].pname<<"\t"<<setw(8)<<process[i].arrivetime<<"\t"<<setw(8)<<process[i].servetime<<"\t"<<setw(8)<<process[i].starttime<<"\t"<<setw(8)<<process[i].endtime<<"\t"<<setw(8)<<process[i].cycletime<<"\t"<<setw(12)<<process[i].withheightcycletime<<endl;
    }
}
void HRRN_PRO()
{
   cout<<"请输入进程的数量"<<endl;
   int n;
   cin>>n;
   input(n);
   sort(process+1,process+n+1,cmp);
   run(n);
   print(n);
}

int main()
{
   HRRN_PRO();
   return 0;
}

4.（抢占式）优先权调度

#include <bits/stdc++.h>

using namespace std;

const int maxn=1010;

struct node
{

    string pname;

    int id;

    double arrivetime;

    double servetime;

    double starttime;

    double endtime;

    double cycletime;

    double withheightcycletime;

    double priority;

} process[maxn];

bool cmp(const node &a,const node &b)
{
    if(a.arrivetime!=b.arrivetime)
        return a.arrivetime<b.arrivetime;
    else
        return a.priority>b.priority;
}
bool operator<(const node &a,const node &b)
{
    return a.priority<b.priority;
}
bool endtimecmp(const node &a,const node &b)
{
        return a.endtime<b.endtime;
}
priority_queue<node>que;
int vis[maxn];
void run(int n)
{
    for(int i=1;i<=n;i++)
    {
        process[i].id=i;
    }
    process[1].endtime=process[1].arrivetime+process[1].servetime;
    process[1].starttime=process[1].arrivetime;
    int vis[maxn];
    memset(vis,0,sizeof(vis));
    vis[1]=1;
    que.push(process[1]);
    int endtime=process[1].starttime+process[1].servetime;
    for(int k=process[1].starttime+1; k<=endtime; k++)
    {
        int index=n+1;
        for(int i=2; i<=n; i++)
            if(!vis[i])
            {
                index=i;
                break;
            }
        if(process[index].arrivetime==k)
        {
            node cur=que.top();
            for(int i=k; i<=endtime; i++)
            {
                int flag=0;
                for(int j=cur.id+1; j<=n; j++)
                    if(process[j].arrivetime==i&&!vis[j]&&process[j].priority>cur.priority)
                    {
                        que.pop();
                        cout<<"当前运行进程："<<cur.pname<<endl;
                        priority_queue<node>t=que;
                        cout<<"当前就绪队列为：";
                        if(!t.empty())
                        {
                            while(!t.empty())
                            {
                                node newcur=t.top();
                                t.pop();
                                cout<<newcur.pname<<" ";
                            }
                            cout<<endl;
                        }
                        else
                        {
                            cout<<"无"<<endl;
                        }
                        process[j].starttime=i;
                        que.push(process[j]);
                        vis[j]=1;
                        flag=1;
                        endtime=i+process[j].servetime;
                        cur.servetime=cur.servetime-(i-cur.starttime);
                        if(cur.servetime==0)
                            process[cur.id].endtime=i;
                        if(cur.servetime>0)
                            que.push(cur);
                        break;
                    }
                    else if(process[j].arrivetime==i&&!vis[j]&&process[j].priority<=cur.priority)
                    {
                        que.push(process[j]);
                        vis[j]=1;
                    }
                if(flag==1)
                    break;
            }


        }
        if(k==endtime)
        {
            node cur=que.top();
            que.pop();
            cout<<"当前运行进程："<<cur.pname<<endl;
            process[cur.id].endtime=k;
            priority_queue<node>t=que;
            cout<<"当前就绪队列为：";
            if(!t.empty())
            {
                while(!t.empty())
                {
                    node cur=t.top();
                    t.pop();
                    cout<<cur.pname<<" ";
                }
                cout<<endl;
            }
            else
            {
                cout<<"无"<<endl;
            }
            if(que.empty())
            {
                for(int i=1; i<=n; i++)
                {
                    if(!vis[i])
                    {
                        process[i].starttime=process[i].arrivetime;
                        que.push(process[i]);
                        k=process[i].arrivetime;
                        process[i].starttime=k;
                        vis[i]=1;
                        break;
                    }

                }
            }
            else
            {
                endtime+=que.top().servetime;
                node cur=que.top();
                que.pop();
                cur.starttime=k;
                que.push(cur);
            }

        }
    }
    for(int i=1;i<=n;i++)
    {
        process[i].cycletime=process[i].endtime-process[i].arrivetime;
        process[i].withheightcycletime=process[i].cycletime/process[i].servetime;
    }
}
void input(int n)
{

    for(int i=1; i<=n; i++)
    {
        cout<<"请输入第"<<i<<"个进程的名称、到达时间、服务时间和优先权重"<<endl;
        cin>>process[i].pname>>process[i].arrivetime>>process[i].servetime>>process[i].priority;
        process[i].cycletime=0;
        process[i].endtime;
        process[i].starttime;
        process[i].withheightcycletime;

    }
}
void print(int n)
{
    sort(process+1,process+n+1,endtimecmp);
    cout<<"进程执行顺序"<<endl;
    for(int i=1; i<=n; i++)
    {
        if(i==1)
            cout<<process[i].pname;
        else
            cout<<"->"<<process[i].pname;
    }
    cout<<endl;
    cout<<"进程名称\t"<<"优先权重\t"<<"服务时间\t"<<"到达时间\t"<<"结束时间\t"<<"周转时间\t"<<"带权周转时间\t"<<endl;
    for(int i=1; i<=n; i++)
    {
        cout<<setiosflags(ios::fixed)<<setprecision(2)<<setw(8)<<process[i].pname<<"\t"<<setw(8)<<process[i].priority<<"\t"<<setw(8)<<process[i].servetime<<"\t"<<setw(8)<<process[i].arrivetime<<"\t"<<setw(8)<<process[i].endtime<<"\t"<<setw(8)<<process[i].cycletime<<"\t"<<setw(10)<<process[i].withheightcycletime<<endl;
    }
}
void PRIORITYWEIGHT_PRO()
{
    cout<<"请输入进程的数量"<<endl;
    int n;
    cin>>n;
    input(n);
    sort(process+1,process+n+1,cmp);
    run(n);
    print(n);
}

int main()
{
    PRIORITYWEIGHT_PRO();
    return 0;
}

5.时间片轮转调度(RR)

#include <bits/stdc++.h>

using namespace std;

const int maxn=1010;

struct node
{

    string pname;

    int id;

    double arrivetime;

    double servetime;

    double starttime;

    double endtime;

    double cycletime;

    double withheightcycletime;

} process[maxn];

bool cmp(const node &a,const node &b)
{
  return a.arrivetime<b.arrivetime;
}
bool endtimecmp(const node &a,const node &b)
{
  return a.endtime<b.endtime;
}

queue<node>que;
int vis[maxn];
void run(int length,int n)
{
    for(int i=1;i<=n;i++)
        process[i].id=i;
    int inque=0;
    memset(vis,0,sizeof(vis));
    int curtime=process[1].arrivetime;
    que.push(process[1]);
    inque++;
    vis[1]=1;
    while(!que.empty())
    {
        while(!que.empty())
        {
            node cur=que.front();
            que.pop();
            if(cur.servetime<=length)
            {
                curtime+=cur.servetime;
                cur.endtime=curtime;
                process[cur.id].endtime=curtime;
                for(int i=inque+1;i<=n;i++)
                {
                    if(process[i].arrivetime<=curtime&&!vis[i])
                    {
                        que.push(process[i]);
                        vis[i]=1;
                        inque++;
                    }
                }
            }
            else
            {
                curtime+=length;
                cur.servetime-=length;
                for(int i=inque+1;i<=n;i++)
                {
                    if(process[i].arrivetime<=curtime&&!vis[i])
                    {
                        que.push(process[i]);
                        vis[i]=1;
                        inque++;
                    }
                }
                que.push(cur);
            }
        }
        if(que.empty())
        {
            for(int i=inque+1;i<=n;i++)
            {
                if(!vis[i])
                {
                    que.push(process[i]);
                    inque++;
                    vis[i]=1;
                    curtime=process[i].arrivetime;
                    break;
                }
            }
        }
    }

    for(int i=1;i<=n;i++)
    {
        process[i].cycletime=process[i].endtime-process[i].arrivetime;
        process[i].withheightcycletime=process[i].cycletime/process[i].servetime;
    }
}
void input(int n)
{

    for(int i=1; i<=n; i++)
    {
        cout<<"请输入第"<<i<<"个进程的名称、到达时间和服务时间"<<endl;
        cin>>process[i].pname>>process[i].arrivetime>>process[i].servetime;
        process[i].cycletime=0;
        process[i].endtime;
        process[i].starttime;
        process[i].withheightcycletime;

    }
}
void print(int n)
{
    sort(process+1,process+n+1,endtimecmp);
    cout<<"进程执行顺序"<<endl;
    for(int i=1; i<=n; i++)
    {
        if(i==1)
            cout<<process[i].pname;
        else
            cout<<"->"<<process[i].pname;
    }
    cout<<endl;
    cout<<"进程名称\t"<<"服务时间\t"<<"到达时间\t"<<"结束时间\t"<<"周转时间\t"<<"带权周转时间\t"<<endl;
    for(int i=1; i<=n; i++)
    {
        cout<<setiosflags(ios::fixed)<<setprecision(2)<<setw(8)<<process[i].pname<<"\t"<<setw(8)<<process[i].servetime<<"\t"<<setw(8)<<process[i].arrivetime<<"\t"<<setw(8)<<process[i].endtime<<"\t"<<setw(8)<<process[i].cycletime<<"\t"<<setw(10)<<process[i].withheightcycletime<<endl;
    }
}
void RR_PRO()
{
    cout<<"请输入进程的数量"<<endl;
    int n;
    cin>>n;
    int length;
    cout<<"请输入时间片长度"<<endl;
    cin>>length;
    input(n);
    sort(process+1,process+n+1,cmp);
    run(length,n);
    print(n);
}

int main()
{
    RR_PRO();
    return 0;
}

//5
//A 0 4
//B 1 3
//C 2 5
//D 3 2
//E 4 4

运行实例

1.先到先服务调度(FCFS)

  

2最短作业优先调度(SJF)

3高响应比优先调度(HRRN)

4（抢占式）优先权调度

5时间片轮转调度(RR)

 

 

 

 

 

 

 

清欢Viki
关注
  • 2
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程的那些事(2)进程和线程调度算法
公众号（猴子数据分析）
08-10 8663
调度算法是指：根据系统的资源分配策略所规定的资源分配算法，如任务A在执行完后，选择哪个任务来执行，使得某个因素（如进程总执行时间，或者磁盘寻道时间等）最小。对于不同的系统目标，通常采用不同的调度算法。 几个常用的操作系统进程调度算法。 1 先来先服务（队列） 先来先服务(FCFS)调度算法是一种最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。当在作业调度中采用该算法时，每次调
常用的进程调度算法
越陌度阡
12-14 6179
进程调度是由操作系统的进程调度程序按照某种策略和算法从就绪态进程中为当前空闲的CPU选择要运⾏的新进程，常用的进程调度算法有以下几种： 1. 先来先服务调度算法 从就绪队列的队⾸选择最先到达的进程，为该进程分配CPU。下面通过一个例子来说明先来先服务算法。 已知：就续队列中有3个进程， 分别为P1、P2、P3，进入系统的时间分别为0、1、2，服务时间分别为24、3、3，求3个进程的系统......
计算机操作系统——进程调度算法
yi_chengyu的博客
12-13 2927
文章目录一、轮转调度算法二、优先级调度算法三、多队列调度算法四、多级反馈队列调度算法五、基于公平原则的调度算法 一、轮转调度算法 二、优先级调度算法 三、多队列调度算法 四、多级反馈队列调度算法 五、基于公平原则的调度算法 ...
进程调度算法5种全
weixin_43902812的博客
04-13 966
操作系统进程调度算法 5种方式都包含 我这里的短作业优先采用的是按照时间和短作业比较方法，判断执行的。 # include <stdio.h> # include <stdlib.h> # include <string.h> # include<iostream> # include<queue> # include<list&...
进程的调度算法
GMLGDJ的博客
05-06 3094
什么时候调度进程 在进程的生命周期中，当进程从一个运行状态到另外一状态变化的时候，其实会触发一次调度。 比如，以下状态的变化都会触发操作系统的调度： 从就绪态->运行态：当进程被创建时，会进入到就绪队列，操作系统会从就绪队列选择一个进程运行； 从运行态->阻塞态：当进程发生I/O事件而阻塞时，操作系统必须选择另外一个进程运行； 从运行态->结束态：当进程退出结束后，操作系统得从就绪队列选择另外一个进程运行； 进程的状态 五状态模型 如图，进入就绪队列，其状态就会变为就.
操作系统进程调度算法
01-13
本文将深入探讨四种常见的进程调度算法：先来先服务（FCFS）、短进程优先（SPF）、高响应比优先（HRN）以及时间片轮转（RR），并结合提供的文件名，我们可以推测这可能是一个关于这些算法实现的编程项目。...
Java模拟操作系统实验之四种进程调度算法实现（FCFS,SJF,RR,HRN）
01-01
本文将深入探讨Java环境下实现的四种进程调度算法：先来先服务(FCFS)、短作业优先(SJF)、时间片轮转(RR)以及高响应比优先(HRN)。这些算法在多任务环境中用于决定哪个进程应该获得CPU的执行权，以达到资源分配的公平...
操作系统实验：时间片轮转RR进程调度算法.doc
05-11
时间片轮转RR进程调度算法 本文档对时间片轮转RR进程调度算法进行了详细的实现和分析。该算法是操作系统中的一种常用的进程调度算法，能够合理地分配CPU时间片，提高系统的效率和公平性。 一、需求分析 时间片...
操作系统进程调度算法图解（FCFS、轮转、SPN、SRT、HRRN、反馈）
热门推荐
haoshen's blog
10-24 2万+
FCFS: 先来先服务，也可以称为先进先出 轮转： 以一个周期性间隔产生时钟中断，此时当前正在运行的进程被置于就绪队列，基于FCFS选择下一个就绪进程             运行。 SPN：最短进程优先，下一次选择所需处理时间最短的进程 SRT：最短剩余时间优先，总是选择预期剩余时间最短的进程 HRRN：最高响应比优先，R=(w+s)/s，其中R表示响应比，w表示已经等待的时间，s表示期
进程调度算法的模拟实现
06-17
操作系统进程调度课设，有先来先服务、 短作业优先 、最短剩余时间优先 、时间片轮换、 高优先权调度五种算法
短作业优先算法源代码
01-15
短作业优先 ：短作业优先调度算法（SJF）是指对短作业或短进程优先调度的算法。 目的：有效的降低作业的平均等待时间，提高系统吞吐量。
短作业优先调度算法
05-12
模拟实现短作业调度算法，具体如下： 1、 设置作业体：作业名，作业的到达时间，服务时间，作业间的链接指针； 2、 进程初始化：由用户输入作业名、作业的到达时间和服务时间进行初始化； 3、 显示函数： 显示当前调度的是哪个作业，后备队列中有哪些作业； 最终显示每个作业的作业名、到达时间、服务时间、完成时间和周转时间； 4、 排序函数：对就已到达的作业按照服务时间进行排序。注意考虑到达时间； 5、 调度函数：每次从已到达的作业队列队首调度优一个作业执行； 6、 删除函数：作业结束后撤销。 注意事项： 1、 测试数据可以随即输入或从文件中读入。 2、 必须要考虑到作业的到达时间 3、 最终能够计算每一个作业的周转时间。
8259_experiment_8259A实现快关灯控制_proteus8259_开关灯_proteus_8259_
09-28
通过8259A实现开关灯循环控制。通过Proteus 8 Professional仿真完成
操作系统作业————优先级调度算法
12-04
操作系统 优先级调度算法 #include "iostream.h" #include "stdio.h" #include "stdlib.h" #include "string.h" #include "windows.h" #define MAX_PROGRAM 50 //系统可承受最大进程数量 char pname[MAX_PROGRAM][5]={"P1","P2","P3","P4","P5","P6","P7","P8","P9","P10", "P11","P12","P13","P14","P15","P16","P17","P18","P19","P20", "P21","P22","P23","P24","P25","P26","P27","P28","P29","P30", "P31","P32","P33","P34","P35","P36","P37","P38","P39","P40", "P41","P42","P43","P44","P45","P46","P47","P48","P49","P50"}; struct PCB //进程控制块
操作系统进程调度算法（5状态）可视化
qq_46717669的博客
05-11 1249
操作系统进程调度算法（5状态）可视化，python，tk.inter
操作系统中的几种常见进程调度算法
windyblankboy的博客
06-11 2万+
首先来看下集中常见的进程调度算法： 1.先来先服务调度算法 2.短作业优先调度算法 3.优先级调度算法 4.高响应比优先调度算法 5.轮转调度算法 6.多级反馈队列 一、先来先服务和短作业（进程）优先调度算法   1.先来先服务调度算法。 先来先服务（FCFS）调度算法是一种最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。FCFS算法比较有利于长作
操作系统概论（4）--进程调度
Sunjihang_123的博客
10-24 886
进程调度：如何分配CPU。（自行回顾进程调度状态图的三模态、五模态） 1.引起进程调度的时机 1）现运行进程运行结束或者因任务完成而正常结束，或者因出现错误而异常结束。 2）现运行进程因某种原因，比如I/O请求，从运行进出入阻塞状态。 3）现运行进程执行某种原语操作，如P操作、阻塞原语等，进入阻塞状态。 4）一个具有更
进程调度算法模拟演示.pdf
最新发布
11-12
"进程调度算法模拟演示.pdf" 这篇文档主要介绍了进程调度算法的模拟演示，旨在帮助理解操作系统中进程管理的重要性和各种调度策略的实施。文档涵盖了先来先服务（FCFS）、时间片轮转以及优先级调度算法，并在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值