操作系统4种进程调度算法（c语言）

已于 2024-04-12 11:44:33 修改
阅读量5.1k 收藏 129
点赞数 25
分类专栏： 计算机操作系统 文章标签： 算法 c语言
于 2023-11-14 00:16:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74337975/article/details/134389053
版权

目录

FCFS

SJF

HPF

RR

 

FCFS

FCFS（First-Come, First-Served）调度算法是一种最简单的进程调度算法，也被称为先来先服务算法。在这种算法中，进程按照它们到达就绪队列的顺序依次执行，即先到达的进程先执行，后到达的进程排队等待。
基本原则是按照进程到达的顺序，逐个地将它们分配给 CPU，直到所有进程都执行完毕。这意味着在FCFS算法中，不考虑进程的执行时间长短或优先级高低，仅仅按照它们进入就绪队列的先后顺序进行调度。
尽管FCFS算法简单，易于理解，但它也有一些缺点。其中一个主要问题是平均等待时间可能较长，尤其是当一些短进程在一些长进程之后到达时。这可能导致低效的利用 CPU 时间，因为较长的进程可能会占用 CPU 较长时间，而其他进程等待的时间较长。
FCFS算法是一种非抢占式调度算法，因为一旦进程开始执行，它将一直运行直到完成，或者直到被更高优先级的进程抢占。

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

// 定义进程结构体
typedef struct
{
    char name[10];
    int enter_time;
    int running_time;
} Program;

// 定义就绪队列结构体
typedef struct
{
    Program **programs;
    int size;
    int capacity;
} ProgramQueue;

// 初始化就绪队列
void InitializeQueue(ProgramQueue *queue, int capacity)
{
    queue->programs = (Program **)malloc(capacity * sizeof(Program *));
    queue->size = 0;
    queue->capacity = capacity;
}

// 将进程加入队列
void EnterQueue(ProgramQueue *queue, Program *program)
{
    if (queue->size < queue->capacity)
    {
        queue->programs[queue->size] = program;
        queue->size++;
    }
}

// 从队列中取出进程
Program *PollQueue(ProgramQueue *queue)
{
    if (queue->size > 0)
    {
        Program *program = queue->programs[0];
        for (int i = 1; i < queue->size; i++)
        {
            queue->programs[i - 1] = queue->programs[i];
        }
        queue->size--;
        return program;
    }
    return NULL;
}

// 执行FCFS调度
void FCFS(Program pro[], int num)
{
    printf("进程 到达时间  服务时间 开始时间 完成时间 周转时间 带权周转时间\n");
    // 按照到达时间排序

    ProgramQueue queue;
    InitializeQueue(&queue, num);
    EnterQueue(&queue, &pro[0]);
    int time = pro[0].enter_time;
    int pronum = 1;
    float sum_T_time = 0, sum_QT_time = 0;

    while (queue.size > 0)
    {
        Program *curpro = PollQueue(&queue);
        if (time < curpro->enter_time)
        {
            time = curpro->enter_time;
        }
        int done_time = time + curpro->running_time;
        int T_time = done_time - curpro->enter_time;
        sum_T_time += T_time;
        float QT_time = (float)T_time / curpro->running_time;
        sum_QT_time += QT_time;
        printf("%s\t%d\t%d\t%d\t%d\t%d\t%.2f\n", curpro->name, curpro->enter_time, curpro->running_time, time, done_time, T_time, QT_time);
        time += curpro->running_time;

        // 进程模拟执行过程
        while (pronum < num && pro[pronum].enter_time <= done_time)
        {
            EnterQueue(&queue, &pro[pronum]);
            pronum++;
        }
    }

    printf("平均周转时间为%.2f\t平均带权周转时间为%.2f\n", sum_T_time / num, sum_QT_time / num);
}

int main()
{
    int num = 3; // 假设有3个进程

    // 初始化进程数组
    Program pro[num];
    strcpy(pro[0].name, "P1");
    pro[0].enter_time = 0;
    pro[0].running_time = 5;

    strcpy(pro[1].name, "P2");
    pro[1].enter_time = 1;
    pro[1].running_time = 3;

    strcpy(pro[2].name, "P3");
    pro[2].enter_time = 3;
    pro[2].running_time = 6;

    // 调用FCFS函数
    FCFS(pro, num);

    return 0;
}

SJF

SJF (Shortest Job First) 是一种进程调度算法，它选择服务时间最短的进程来执行，以最小化平均等待时间。这是一种非抢占式的调度算法，即一旦进程开始执行，就一直执行到完成，除非有更短的作业进入就绪队列。
主要思想是通过预测进程的服务时间来选择下一个执行的进程，以确保总体上获得最短的作业完成时间。这样可以提高系统的吞吐量和响应速度。
SJF 可以分为两种类型：
1. 非抢占式 SJF： 一旦进程开始执行，就不会被中断，直到它完成。只有在进程完成后，系统才会选择下一个最短的作业。
2. 抢占式 SJF：允许更短作业中途插入执行。如果新进程的服务时间比当前正在执行的进程更短，那么系统会中断当前进程，转而执行新的进程。
实现 SJF 调度算法时，需要对进程按照服务时间进行排序，以便在选择下一个要执行的进程时能够方便地找到服务时间最短的进程。这通常通过使用排序算法（如快速排序或插入排序）来实现。需要注意的是，SJF 算法的一个问题是它对于长服务时间的进程可能会导致其他进程长时间等待，可能会出现饥饿（Starvation）的情况。

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

// 定义进程结构体
typedef struct
{
    char name[10];
    int enter_time;
    int running_time;
} Program;

// 定义就绪队列结构体
typedef struct
{
    Program **programs;
    int size;
    int capacity;
} ProgramQueue;

// 初始化就绪队列
void InitializeQueue(ProgramQueue *queue, int capacity)
{
    queue->programs = (Program **)malloc(capacity * sizeof(Program *));
    queue->size = 0;
    queue->capacity = capacity;
}

// 将进程加入队列
void EnterQueue(ProgramQueue *queue, Program *program)
{
    if (queue->size < queue->capacity)
    {
        queue->programs[queue->size] = program;
        queue->size++;
    }
}

// 从队列中取出进程
Program *PollQueue(ProgramQueue *queue)
{
    if (queue->size > 0)
    {
        Program *program = queue->programs[0];
        for (int i = 1; i < queue->size; i++)
        {
            queue->programs[i - 1] = queue->programs[i];
        }
        queue->size--;
        return program;
    }
    return NULL;
}

// 按服务时间排序的比较函数
int CompareByRunningTime(const void *a, const void *b)
{
    return ((Program *)a)->running_time - ((Program *)b)->running_time;
}

// 执行SJF调度
void SJF(Program pro[], int num)
{
    printf("进程 到达时间 服务时间 开始时间 完成时间 周转时间 带权周转时间\n");

    // 按照服务时间排序
    qsort(pro, num, sizeof(Program), CompareByRunningTime);

    ProgramQueue queue;
    InitializeQueue(&queue, num);
    int time = 0;
    int pronum = 0;
    float sum_T_time = 0, sum_QT_time = 0;

    while (pronum < num || queue.size > 0)
    {
        while (pronum < num && pro[pronum].enter_time <= time)
        {
            EnterQueue(&queue, &pro[pronum]);
            pronum++;
        }

        if (queue.size > 0)
        {
            Program *curpro = PollQueue(&queue);
            int done_time = time + curpro->running_time;
            int T_time = done_time - curpro->enter_time;
            sum_T_time += T_time;
            float QT_time = (float)T_time / curpro->running_time;
            sum_QT_time += QT_time;
            printf("%s\t%d\t%d\t%d\t%d\t%d\t%.2f\n", curpro->name, curpro->enter_time, curpro->running_time, time, done_time, T_time, QT_time);
            time += curpro->running_time;
        }
        else
        {
            time = pro[pronum].enter_time;
        }
    }

    printf("平均周转时间为%.2f\t平均带权周转时间为%.2f\n", sum_T_time / num, sum_QT_time / num);
}

int main()
{
    int num = 3; // 假设有3个进程

    // 初始化进程数组
    Program pro[num];
    strcpy(pro[0].name, "P1");
    pro[0].enter_time = 0;
    pro[0].running_time = 5;

    strcpy(pro[1].name, "P2");
    pro[1].enter_time = 1;
    pro[1].running_time = 3;

    strcpy(pro[2].name, "P3");
    pro[2].enter_time = 3;
    pro[2].running_time = 6;

    // 调用SJF函数
    SJF(pro, num);

    return 0;
}

HPF

高优先级先执行（High Priority First, HPF）调度算法是一种基于进程优先级的调度策略。该算法根据进程的优先级来决定下一个执行的进程。优先级越高的进程将优先执行，以确保更重要或紧急的任务能够尽快得到处理。
每个进程都被赋予一个优先级值，通常是一个整数。较小的优先级值表示较高的优先级，而较大的值表示较低的优先级。在每个调度点，系统选择具有最高优先级的就绪进程来执行。这确保了具有更高优先级的任务能够更快地获得处理。HPF 调度算法可以是抢占性的或非抢占性的。抢占性的 HPF 允许正在执行的进程被更高优先级的进程中断，以便立即执行更高优先级的任务。当进程到达时，将其插入到就绪队列中，按照优先级进行排序。具有更高优先级的进程将在队列的前部。在每个时间片或事件发生时，选择就绪队列中具有最高优先级的进程执行。执行完毕后，继续选择下一个最高优先级的就绪进程。
需要注意，过度依赖高优先级可能导致低优先级任务长时间等待，产生饥饿（starvation）现象。因此，在设计调度算法时，需要平衡对高优先级任务的服务和对低优先级任务的公平性。

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

// 定义进程结构体
typedef struct
{
    char name[10];
    int enter_time;
    int running_time;
    int priority;
} Program;

// 定义就绪队列结构体
typedef struct
{
    Program **programs;
    int size;
    int capacity;
} ProgramQueue;

// 初始化就绪队列
void InitializeQueue(ProgramQueue *queue, int capacity)
{
    queue->programs = (Program **)malloc(capacity * sizeof(Program *));
    queue->size = 0;
    queue->capacity = capacity;
}

// 将进程加入队列
void EnterQueue(ProgramQueue *queue, Program *program)
{
    if (queue->size < queue->capacity)
    {
        queue->programs[queue->size] = program;
        queue->size++;
    }
}

// 从队列中取出进程
Program *PollQueue(ProgramQueue *queue)
{
    if (queue->size > 0)
    {
        Program *program = queue->programs[0];
        for (int i = 1; i < queue->size; i++)
        {
            queue->programs[i - 1] = queue->programs[i];
        }
        queue->size--;
        return program;
    }
    return NULL;
}

// 按优先级排序的比较函数
int CompareByPriority(const void *a, const void *b)
{
    return ((Program *)a)->priority - ((Program *)b)->priority;
}

// 执行HPF调度
void HPF(Program pro[], int num)
{
    printf("进程 到达时间 服务时间 优先级 开始时间 完成时间 周转时间 带权周转时间\n");

    // 按照优先级排序
    qsort(pro, num, sizeof(Program), CompareByPriority);

    ProgramQueue queue;
    InitializeQueue(&queue, num);
    int time = 0;
    int pronum = 0;
    float sum_T_time = 0, sum_QT_time = 0;

    while (pronum < num || queue.size > 0)
    {
        while (pronum < num && pro[pronum].enter_time <= time)
        {
            EnterQueue(&queue, &pro[pronum]);
            pronum++;
        }

        if (queue.size > 0)
        {
            Program *curpro = PollQueue(&queue);
            int done_time = time + curpro->running_time;
            int T_time = done_time - curpro->enter_time;
            sum_T_time += T_time;
            float QT_time = (float)T_time / curpro->running_time;
            sum_QT_time += QT_time;
            printf("%s\t%d\t%d\t%d\t%d\t%d\t%d\t%.2f\n", curpro->name, curpro->enter_time, curpro->running_time, curpro->priority, time, done_time, T_time, QT_time);
            time += curpro->running_time;
        }
        else
        {
            time = pro[pronum].enter_time;
        }
    }

    printf("平均周转时间为%.2f\t平均带权周转时间为%.2f\n", sum_T_time / num, sum_QT_time / num);
}

int main()
{
    int num = 3; // 假设有3个进程

    // 初始化进程数组
    Program pro[num];
    strcpy(pro[0].name, "P1");
    pro[0].enter_time = 0;
    pro[0].running_time = 5;
    pro[0].priority = 3;

    strcpy(pro[1].name, "P2");
    pro[1].enter_time = 1;
    pro[1].running_time = 3;
    pro[1].priority = 1;

    strcpy(pro[2].name, "P3");
    pro[2].enter_time = 3;
    pro[2].running_time = 6;
    pro[2].priority = 2;

    // 调用HPF函数
    HPF(pro, num);

    return 0;
}

RR

轮转调度算法（Round Robin Scheduling）是一种常见的操作系统调度算法之一，它通过给每个进程分配一个时间片（时间量），然后按照轮转的方式依次执行每个进程，直到完成或者时间片用尽。

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

// 定义进程结构体
typedef struct
{
    char name[10];
    int arrival_time;
    int burst_time;
    int remaining_time;
} Process;

// 定义就绪队列结构体
typedef struct
{
    Process **processes;
    int size;
    int capacity;
} ProcessQueue;

// 初始化就绪队列
void InitializeQueue(ProcessQueue *queue, int capacity)
{
    queue->processes = (Process **)malloc(capacity * sizeof(Process *));
    queue->size = 0;
    queue->capacity = capacity;
}

// 将进程加入队列
void EnterQueue(ProcessQueue *queue, Process *process)
{
    if (queue->size < queue->capacity)
    {
        queue->processes[queue->size] = process;
        queue->size++;
    }
}

// 从队列中取出进程
Process *PollQueue(ProcessQueue *queue)
{
    if (queue->size > 0)
    {
        Process *process = queue->processes[0];
        for (int i = 1; i < queue->size; i++)
        {
            queue->processes[i - 1] = queue->processes[i];
        }
        queue->size--;
        return process;
    }
    return NULL;
}

// 轮转调度函数
void RoundRobin(Process processes[], int num_processes, int time_slice)
{
    printf("进程 到达时间 服务时间 开始时间 完成时间 周转时间 带权周转时间\n");

    // 初始化就绪队列
    ProcessQueue queue;
    InitializeQueue(&queue, num_processes);

    int time = 0;
    int remaining_processes = num_processes;

    while (remaining_processes > 0)
    {
        for (int i = 0; i < num_processes; ++i)
        {
            if (processes[i].arrival_time <= time && processes[i].remaining_time > 0)
            {
                // 进程可执行
                EnterQueue(&queue, &processes[i]);
            }
        }

        if (queue.size > 0)
        {
            Process *current_process = PollQueue(&queue);

            // 执行进程
            int execution_time = (current_process->remaining_time <= time_slice) ? current_process->remaining_time : time_slice;
            printf("%s\t%d\t%d\t%d\t%d\t%d\t%.2f\n", current_process->name, current_process->arrival_time, current_process->burst_time,
                   time, time + execution_time, time + execution_time - current_process->arrival_time,
                   (float)(time + execution_time - current_process->arrival_time) / current_process->burst_time);

            // 更新进程信息
            current_process->remaining_time -= execution_time;
            time += execution_time;

            // 将未执行完的进程重新加入队列
            if (current_process->remaining_time > 0)
            {
                EnterQueue(&queue, current_process);
            }
            else
            {
                --remaining_processes;
            }
        }
        else
        {
            // 等待下一个进程到达
            time++;
        }
    }

    printf("轮转调度算法完成.\n");
}

int main()
{
    int num_processes = 3;
    int time_slice = 2;

    // 初始化进程数组
    Process processes[num_processes];
    strcpy(processes[0].name, "P1");
    processes[0].arrival_time = 0;
    processes[0].burst_time = 5;
    processes[0].remaining_time = processes[0].burst_time;

    strcpy(processes[1].name, "P2");
    processes[1].arrival_time = 1;
    processes[1].burst_time = 3;
    processes[1].remaining_time = processes[1].burst_time;

    strcpy(processes[2].name, "P3");
    processes[2].arrival_time = 3;
    processes[2].burst_time = 6;
    processes[2].remaining_time = processes[2].burst_time;

    // 调用轮转调度函数
    RoundRobin(processes, num_processes, time_slice);

    return 0;
}

 

 

操作系统进程调度算法C语言代码
12-08
操作系统进程调度算法C语言代码 本算法包含四种调度:先到先服务，短作业优先，时间片轮转，优先级优先！
进程调度c语言实现
12-25
先来先服务及时间片轮转算法的c语言实现
C语言模拟进程调度的实现（抢占式动态优先级调度、时间片轮转调度）
最新发布
qq_73896708的博客
11-05 1371
任务要求：要求设计一个模拟进程调度的算法。本文设计的算法仅包含抢占式的动态优先级调度算法和时间片轮转调度两种算法。
操作系统实验二（调度算法模拟-先进先出-时间片轮转法-优先服务调度算法）
GoodLuckAC的博客
05-26 1万+
实验二 进程调度 一、     实验目的 1.       理解进程运行的并发性。  2.       理解处理器的三级调度。 3.       掌握先来先服务的进程调度算法。 4.       掌握短进程优先的进程调度算法。 5.       掌握时间片轮转的进程调度算法。  二、     实验设备 1.     安装windows或者linux操作系统的PC机 2.    
操作系统——四种进程调度算法模拟实现（C语言）
热门推荐
mcr1379673758的博客
05-03 6万+
操作系统——四种进程调度算法模拟实现（C语言）
操作系统进程调度算法 c语言实现
04-07
实现进程调度算法，具有后备序列的调度 题目：设计一个有 N个进程共行的进程调度程序。 进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。 每个进程有一个进程控制块（ PCB）表示。进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。 进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。进程的到达时间为进程输入的时间。 进程的运行时间以时间片为单位进行计算。 每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。 就绪进程获得 CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。 如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。 每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。 重复以上过程，直到所有进程都完成为止。
【C语言源代码】 操作系统-短进程优先-进程调度算法
02-10
C语言实现：短进程优先-进程调度算法 1. 采用“短进程优先”调度算法对五个进程进行调度。每个进程有一个进程控制块（ PCB）表示。进程控制块可以包含如下信息：进程名、到达时间、需要运行时间、已用CPU时间、进程状态等等。 2. 每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。 每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。重复以上过程，直到所要进程都完成为止。
C语言实现操作系统进程调度
12-20
2、进程调度算法模拟 先来先服务、短作业优先、时间片轮转、基于静态优先级的调度，基于高响应比优先的动态优先级调度、时间片轮转调度算法实现，能够输出调度情况，并计算周转时间和平均周转时间。要求使用链表，进程个数由用户提供，按照进程的实际个数生成PCB，程序能够让用户选择使用哪种调度算法，能够在Linux环境运行并验证结果。程序要考虑用户界面的友好性和使用方便性
C语言进程调度
10-19
用C实现进程轮转调度和优先级调度，具体要求： 设计一个程序,根据不同的调度算法模拟操作系统对进程的调度。 调度算法: 时间片循环法 1、 设计进程控制块PBC表结构，适用循环时间片轮转算法。 2、 PBC结构通常包括以下信息：进程名、进程优先数、轮转时间片、进程的CPU时间，进程状态等。根据调度算法不同，PCB结构可作适当的调整。 3、 建立进程队列。对不同的算法编制不同的入链程序。 程序要求达到的运行效果：在设置好进程数量、调度算法后，系统能按设定的参数运行，并在屏幕上交替显示就绪队列和完成队列的进程名等信息。
操作系统——进程调度 C语言版
li1441853031的博客
07-01 3536
先来先服务FCFS算法：进程先进入的先服务。 短作业优先SJF算法：根据当前到来的进程，筛选当前所有进程中所需运行时间最短的进程。 时间片轮转算法：根据时间片的大小，切换进程，直到每个进程都运行完成。 计算出每个进程的开始时间，结束时间，周转时间T=开始时间-到达时间，带权周转时间W = T/运行时间，平均周转时间，平均带权周转时间。 #include <stdio.h> #include <stdlib.h> #include<string.h> typedef str
操作系统电梯调度算法c语言实现
03-22
假设要求从系统中输入N个需访问的柱面号，当前磁头的移动方向由键盘输入(1代表磁头从外往内移动，-1代表磁头由内往外移动)，当前磁头刚完成访问序号为M的柱面，请编程输出采用电梯调度算法得到的柱面访问序列号，...
进程调度和作业调度算法C语言实现
04-13
操作系统os进程调度，作业调度以及请求分页系统的实现，其中进程调度涉及FCFS算法，时间片轮转法以及多级反馈队列实现。作业调度涉及FCFS以及短作业优先等。有源代码以及文档解释
进程调度算法C语言版
03-12
这是一个关于进程调度的算法，这是一个关于进程调度的算法，这是一个关于进程调度的算法，
进程调度模拟，自主选择调度算法（C语言实现）
05-29
NULL 博文链接：https://touch-2011.iteye.com/blog/1042338
操作系统课程设计 用C语言实现进程调度
12-03
用C语言实现进程调度 操作系统课程设计
进程调度模拟(C语言实现)
05-29
NULL 博文链接：https://touch-2011.iteye.com/blog/1047163
操作系统 短进程调度算法 c语言（文档+源代码 已测试）
11-20
操作系统 短进程调度算法 c语言 实现 操作系统 是计算机科学中的一门重要课程，研究操作系统的基本原理、结构、组件和功能。本文将详细介绍操作系统中短进程调度算法的实现，使用 C 语言编写。 短进程调度算法是...
操作系统--进程调度（C语言）
d_eng_的博客
07-08 4172
#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语言实现
low5252的博客
04-08 5136
进程调度算法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语言实现四种操作系统进程调度算法
这段C语言代码实现了一个简单的操作系统进程调度模拟器，用于演示四种不同的进程调度算法：先到先服务（First-Come, First-Served, FCFS）、短作业优先（Shortest Job First, SJF）、时间片轮转（Round Robin, RR）...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值