操作系统——进程调度 C语言版

已于 2022-06-17 18:33:46 修改
阅读量3.4k 收藏 109
点赞数 4
分类专栏： 操作系统 文章标签： 操作系统 c语言
于 2021-07-01 18:35:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/li1441853031/article/details/118393257
版权

先来先服务FCFS算法：进程先进入的先服务。
短作业优先SJF算法：根据当前到来的进程，筛选当前所有进程中所需运行时间最短的进程。
时间片轮转算法：根据时间片的大小，切换进程，直到每个进程都运行完成。
计算出每个进程的开始时间，结束时间，周转时间T=开始时间-到达时间，带权周转时间W = T/运行时间，平均周转时间，平均带权周转时间。

#include <stdio.h>
#include <stdlib.h>
#include<string.h>
typedef struct P
{
    char name;//进程名字
    int come;//进程到达时间
    int need;//进程所需运行时间
    int start;//进程开始运行时间
    int finish;//进程运行结束时间
    int flag;
    struct P *next;
} P;
P p[5];
int n = 5;
char str[100] = {0};
//先来先服务
void FCFS()
{
    int start[n];//开始时间
    int success[n];//完成时间
    int t[n];
    float w[n];
    float tsum =0,wsum = 0;
    start[0] = p[0].come;
    success[0]=p[0].need+p[0].come;
    for(int i = 1; i<n; i++)
    {
        success[i] = success[i-1]+p[i].need;
        start[i] = success[i-1];
    }
    printf("FCFS算法：\n");
    for(int i=0; i<n; i++)
    {
        t[i] = success[i]-p[i].come;
        tsum = t[i] + tsum;
        w[i] = (float)t[i]/p[i].need;
        wsum = wsum+w[i];
        printf("%c开始时间：%d  周转时间T:  %d  带权周转时间W:  %.2lf\n",p[i].name,start[i],t[i],w[i]);
    }
    printf("\n平均周转时间：%.2lf\n",(float)tsum/n);
    printf("\n平均带权周转时间：%.2lf\n",wsum/n);
}
void sort(int s,int k)//开始，结束
{
    P temp;
    for(int i = s; i<k-1; i++)
    {
        for(int j = i+1; j<k; j++)
        {
            if(p[i].need>p[j].need)
            {
                temp = p[i];
                p[i]= p[j];
                p[j] = temp;
            }
        }
    }
}
//短作业优先
void SJF()
{
    int start[n];//开始时间
    int success[n];
    int t[n];
    float w[n];
    int j;
    float tsum = 0,wsum = 0;
    /*
    for(int i = 0;i<n;i++)//初始化未激活状态0
    {
        p[i].flag = 0;
    }
    */
    start[0] = p[0].come;
    success[0]=p[0].need+p[0].come;
    for(int i = 1; i<n; i++)
    {
        for(j = i; j<n; j++)
        {
            if(p[j].come>success[i-1])
            {
                j=j+1;
                break;
            }

        }
        sort(i,j);//到达时间早于当前进程结束时间的激活，进行排序，取运行时间最小的进程
        success[i] = success[i-1]+p[i].need;
        start[i] = success[i-1];
    }
    /*
    for(j = 1;p[j].come<=success[0]&&j<n;j++)
    {

    }
    sort(1,j);
    success[1] = success[0]+p[1].need;
    */

    /*
    for(int i = 1;i<n;i++)
    {
        success[i] = success[i-1]+p[i].need;
        start[i] = success[i-1];
    }
    */
    printf("SJF算法：\n");
    for(int i=0; i<n; i++)
    {
        t[i] = success[i]-p[i].come;
        tsum = t[i] + tsum;
        w[i] = (float)t[i]/p[i].need;
        wsum = wsum+w[i];
        printf("%c 开始时间：%d  周转时间T:  %d  带权周转时间W:  %.2lf\n",p[i].name,start[i],t[i],w[i]);
    }
    printf("\n平均周转时间：%.2lf\n",(float)tsum/n);
    printf("\n平均带权周转时间：%.2lf\n",wsum/n);
}
void TT()
{
    int time = 0;
    int count[n];
    int q;
    int a = 1;//循环标志
    int c = 0;//记录数组长度
    int sum = 0;//数组总长
    int t[n];
    float w[n];
    float tsum = 0,wsum = 0;
    printf("请输入时间片\n");
    scanf(" %d",&q);
    for(int i = 0; i<n; i++)
    {
        p[i].flag = 1;
        count[i] = p[i].need;
        sum = sum + p[i].need;
    }
    while(a)
    {
        for(int i = 0; i<n; i++)
        {
            if(p[i].flag==1)
            {
                if(count[i]-q>0)//未完成
                {
                    for(int j = 0;j<q;j++)
                    {
                        //printf("%c ",p[i].name);
                        c++;
                        str[c] = p[i].name;
                    }
                    count[i] = count[i]-q;
                }else if(count[i]-q == 0)//完成
                {
                    for(int j = 0;j<q;j++)
                    {
                        //printf("%c ",p[i].name);
                        c++;
                        str[c] = p[i].name;
                    }
                    count[i] = count[i]-q;
                    p[i].flag = 0;
                }else if(count[i]-q < 0)//完成
                {
                    for(int j = 0;j<count[i];j++)
                    {
                        //printf("%c ",p[i].name);
                        c++;
                        str[c] = p[i].name;
                    }
                    count[i] = 0;
                    p[i].flag = 0;
                }
            }
        }

        if(c==sum)
            a = 0;
    }
    for(int i = 1;i<=c;i++)
    {
        printf("%c ",str[i]);
    }
    for(int i = c ;i>=1;i--)//查找完成时间
    {
        if(str[i]=='a')
        {
            p[0].finish = i;
            break;
        }
    }
    for(int i = c ;i>=1;i--)//查找完成时间
    {
        if(str[i]=='b')
        {
            p[1].finish = i;
            break;
        }
    }
    for(int i = c ;i>=1;i--)//查找完成时间
    {
        if(str[i]=='c')
        {
            p[2].finish = i;
            break;
        }
    }
    for(int i = c ;i>=1;i--)//查找完成时间
    {
        if(str[i]=='d')
        {
            p[3].finish = i;
            break;
        }
    }
    for(int i = c ;i>=1;i--)//查找完成时间
    {
        if(str[i]=='e')
        {
            p[4].finish = i;
            break;
        }
    }
    printf("时间片轮转算法：\n");
    //完成时间
    printf("完成时间\n");
    for(int i = 0;i<n;i++)
    {
        printf("%d ",p[i].finish);
    }
    printf("\n");
    for(int i=0; i<n; i++)
    {
        t[i] = p[i].finish-p[i].come;
        tsum = t[i] + tsum;
        w[i] = (float)t[i]/p[i].need;
        wsum = wsum+w[i];
        printf("%c 周转时间T:  %d  带权周转时间W:  %.2lf\n",p[i].name,t[i],w[i]);
    }
    printf("\n平均周转时间：%.2lf\n",(float)tsum/n);
    printf("\n平均带权周转时间：%.2lf\n",wsum/n);
}
void sortQuan(int *quan)//开始，结束
{
    P temp;
    for(int i = 1; i<n-1; i++)
    {
        for(int j = i+1; j<n; j++)
        {
            if(quan[j]>quan[i])
            {
                temp = p[i];
                p[i]= p[j];
                p[j] = temp;
            }
        }
    }
}
void SN()
{
    int success[n];
    int t[n];
    float w[n];
    int j;
    int quan[n];
    float tsum = 0,wsum = 0;
    success[0]=p[0].need+p[0].come;
    printf("请输入各权值\n");
    for(int i=0;i<n;i++)
    {
        scanf(" %d",&quan[i]);
    }
    sortQuan(quan);
    for(int i = 1; i<n; i++)
    {
        success[i] = success[i-1]+p[i].need;
    }
    printf("静态非抢占算法：\n");
    for(int i=0; i<n; i++)
    {
        t[i] = success[i]-p[i].come;
        tsum = t[i] + tsum;
        w[i] = (float)t[i]/p[i].need;
        wsum = wsum+w[i];
        printf("%c 周转时间T:  %d  带权周转时间W:  %.2lf\n",p[i].name,t[i],w[i]);
    }
    printf("\n平均周转时间：%.2lf\n",(float)tsum/n);
    printf("\n平均带权周转时间：%.2lf\n",wsum/n);
}
int main()
{
    int r,f = 1;
    printf("请输入5个进程的名字、到达时间 和 服务时间\n");
    for(int i = 0; i<n; i++)
    {
        scanf(" %c %d %d",&p[i].name,&p[i].come,&p[i].need);
    }
    printf("**************\n\n");
    printf("1.FCFS\n");
    printf("2.短作业优先SJF\n");
    printf("3.时间片轮转\n");
    printf("4.静态非抢占\n");
    printf("5.退出\n");
    printf("**************\n\n");

    while(f)
    {
        scanf(" %d",&r);
        switch(r)
        {
            case 1:
                FCFS();
                break;
            case 2:
                SJF();
                break;
            case 3:
                TT();
                break;
            case 4:
                SN();
                break;
            case 5:
                f = 0;

        }
    }

    return 0;
}

运行截图

FCFS算法运行截图
SJF算法运行截图
时间片轮转调度算法运行截图
静态非抢占调度算法运行截图

木子Link
关注
专栏目录
操作系统--进程调度（C语言）
d_eng_的博客
07-08 4133
#include<stdio.h> #include<stdlib.h> #include #include<malloc.h> using namespace std; struct PCB_type { int pid; //进程名 int state; //进程状态 2–表示"执行"状态 1–表示"就绪"状态 0–表示"阻塞"状态 int cpu_t......
操作系统进程调度算法C语言代码
12-08
操作系统进程调度算法C语言代码 本算法包含四种调度:先到先服务，短作业优先，时间片轮转，优先级优先！
操作系统进程调度算法 c语言实现
04-07
实现进程调度算法，具有后备序列的调度 题目：设计一个有 N个进程共行的进程调度程序。 进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。 每个进程有一个进程控制块（ PCB）表示。进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。 进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。进程的到达时间为进程输入的时间。 进程的运行时间以时间片为单位进行计算。 每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。 就绪进程获得 CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。 如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。 每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。 重复以上过程，直到所有进程都完成为止。
C语言-进程控制编程
最新发布
qq_55869380的博客
09-29 1223
一篇学懂多进程编程
进程调度算法C语言实现
low5252的博客
04-08 5054
进程调度算法C语言实现 #define _CRT_SECURE_NO_WARNINGS #define NUMBER 5 #include <stdio.h> #include <windows.h> char process_name[NUMBER] = { 'A', 'B', 'C', 'D', 'E' }; int arrive_time[NUMBER] = { 0...
【C语言源代码】 操作系统-短进程优先-进程调度算法
02-10
C语言实现：短进程优先-进程调度算法 1. 采用“短进程优先”调度算法对五个进程进行调度。每个进程有一个进程控制块（ PCB）表示。进程控制块可以包含如下信息：进程名、到达时间、需要运行时间、已用CPU时间、进程状态等等。 2. 每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。 每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。重复以上过程，直到所要进程都完成为止。
操作系统4种进程调度算法（c语言）
weixin_74337975的博客
11-14 4140
抢占性的 HPF 允许正在执行的进程被更高优先级的进程中断，以便立即执行更高优先级的任务。需要注意的是，SJF 算法的一个问题是它对于长服务时间的进程可能会导致其他进程长时间等待，可能会出现饥饿（Starvation）的情况。这是一种非抢占式的调度算法，即一旦进程开始执行，就一直执行到完成，除非有更短的作业进入就绪队列。在这种算法中，进程按照它们到达就绪队列的顺序依次执行，即先到达的进程先执行，后到达的进程排队等待。如果新进程的服务时间比当前正在执行的进程更短，那么系统会中断当前进程，转而执行新的进程。
操作系统——进程调度算法（C++）.txt
11-28
https://blog.csdn.net/qq_45913057/article/details/109690121
2020初学者理解的操作系统——进程调度算法简单例题
01-09
对于下列每种调度算法，计算其平均周转时间和平均等待时间，进程切换开销可忽略： （a）时间片轮转（假设时间片尾2min） （b）优先级调度 （c）先来先服务（按照次序10、6、2、4、8） （d）最短作业优先 对于以上...
操作系统——进程调度实验
05-31
输入进程个数以后，随机生成各个进程的名称、优先级、所需时间、运行时间=0；第一轮按优先级排序后，进行进程调度，每调度一次减少一次所需时间，降低一次优先级，进程完成以后，就自动回收，直到所有进程调度完成。
操作系统——PCB模拟代码.zip_control system_优先级调度_动态优先 界面_模拟操作系统_进程
09-23
在这个“操作系统——PCB模拟代码”中，我们主要关注的是进程控制块（PCB）、优先级调度以及动态优先级界面的实现，这些都是操作系统中至关重要的概念。 进程控制块（PCB，Process Control Block）是操作系统用来...
C语言实现操作系统进程调度
12-20
2、进程调度算法模拟 先来先服务、短作业优先、时间片轮转、基于静态优先级的调度，基于高响应比优先的动态优先级调度、时间片轮转调度算法实现，能够输出调度情况，并计算周转时间和平均周转时间。要求使用链表，进程个数由用户提供，按照进程的实际个数生成PCB，程序能够让用户选择使用哪种调度算法，能够在Linux环境运行并验证结果。程序要考虑用户界面的友好性和使用方便性
进程调度模拟，自主选择调度算法（C语言实现）
05-29
NULL 博文链接：https://touch-2011.iteye.com/blog/1042338
进程调度算法C语言版
03-12
这是一个关于进程调度的算法，这是一个关于进程调度的算法，这是一个关于进程调度的算法，
进程调度c语言实现
12-25
先来先服务及时间片轮转算法的c语言实现
操作系统 短进程调度算法 c语言（文档+源代码 已测试）
11-20
操作系统 用c语言实现的短进程调度算法（文档+源代码 已测试） Word版 内含源代码、说明文档、演示截图
操作系统进程调度实现算法（c语言版）
qq_41552756的博客
06-21 2万+
#include &lt;stdio.h&gt;#include &lt;stdlib.h&gt;#include &lt;windows.h&gt;   //包含sleep函数#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFESIBLE -1#define OVERFLOW -2struct PCB{ char...
操作系统进程调度模拟算法实现（C语言版）
热门推荐
闭关修炼——暂退
05-08 2万+
目录 1 先到先服务(FCFS) 2. 短进程优先（非抢占和抢占）算法(SPF) 1 先来先服务(FCFS) 1.1算法描述 先来先服务调度算法描述：按照进程进入的先后次序来分配处理器。先进入就绪队列的进程优先被挑选，运行进程一旦占有处理器将一直运行下去，直到运行结束或被阻塞，这是非抢占式调度。 1.2实验内容 编写并调试一个模拟的进程调度程序，采用 “先来...
【操作系统】c语言--进程调度算法(FCFS和SPN)
努力让自己的能力配得上梦想.
07-05 1942
先到先服务进程调度算法 先来先服务进程调度算法（FCFS）是按照进程到达的先后顺序进行调度的算法。 当一个进程到达时，它会被放到进程队列的末尾，并在前面等待其他进程执行完毕。 一旦轮到该进程执行，它会一直执行直到完成，或者被阻塞，或者需要等待I/O操作完成。短进程优先调度算法 短进程优先调度算法（SPN）是根据进程执行时间短的优先级进行调度的算法。 当一个进程到达时，系统会估算其执行时间，如果短于当前正在执行的进程，那么该进程就会优先执行。如果有多个进程具有相同的最短执行时间，那么默认使用FCFS算法。
操作系统进程调度c语言实现
05-30
以下是一个简单的 C 语言实现，使用的是时间片轮转调度算法： ```c #include<stdio.h> #include<stdlib.h> #define N 5 // 进程数 #define TIME_QUANTUM 3 // 时间片长度 typedef struct PCB{ int pid; // 进程ID int arrive_time; // 到达时间 int execute_time; // 执行时间 int remain_time; // 剩余时间 int priority; // 优先级 }PCB; int queue[N]; // 进程队列 int front = -1, rear = -1; // 队头、队尾指针 PCB processes[N]; // 进程数组 // 进程入队 void enqueue(int pid){ if(rear == N-1) rear = -1; // 队尾指针回到队头 queue[++rear] = pid; if(front == -1) front = 0; } // 进程出队 int dequeue(){ int pid = queue[front++]; if(front == N) front = 0; // 队头指针回到队头 if(front == rear+1) front = rear = -1; // 队列为空 return pid; } // 时间片轮转调度 void RR(){ int time = 0; // 当前时间 int pid = -1; // 当前执行的进程 int round = 0; // 记录轮转次数 int i; // 初始化进程数组 for(i=0; i<N; i++){ printf("请输入第%d个进程的信息（进程ID 到达时间 执行时间 优先级）：", i+1); scanf("%d %d %d %d", &processes[i].pid, &processes[i].arrive_time, &processes[i].execute_time, &processes[i].priority); processes[i].remain_time = processes[i].execute_time; } // 时间片轮转调度 while(1){ for(i=0; i<N; i++){ if(processes[i].arrive_time <= time && processes[i].remain_time > 0){ enqueue(i); // 将到达时间小于等于当前时间，且剩余时间大于0的进程入队 } } if(front == -1){ // 队列为空 printf("所有进程已经执行完毕！\n"); break; } pid = dequeue(); // 取出队首进程 if(processes[pid].remain_time <= TIME_QUANTUM){ // 进程执行完毕 time += processes[pid].remain_time; processes[pid].remain_time = 0; printf("进程%d执行完毕，用时%d秒\n", processes[pid].pid, time-processes[pid].arrive_time); } else{ // 进程未执行完毕，放回队尾 time += TIME_QUANTUM; processes[pid].remain_time -= TIME_QUANTUM; printf("进程%d运行%d秒后被放回队列\n", processes[pid].pid, TIME_QUANTUM); enqueue(pid); } round++; // 记录轮转次数 if(round % N == 0){ // 每轮转一次，打印一次队列中的进程 printf("当前时间：%d\n", time); printf("队列中的进程："); for(i=front; i<=rear; i++){ printf("%d ", processes[queue[i]].pid); } printf("\n"); } } } int main(){ RR(); return 0; } ``` 以上代码为一个简单的时间片轮转调度的实现，可以根据实际需求进行修改和优化。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

木子Link

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

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

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

打赏作者

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

抵扣说明：

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

余额充值