【进程调度模拟】Linux “操作系统进程调度算法模拟：时间片轮转、优先级调度与先来先服务“

最新推荐文章于 2025-02-19 20:30:36 发布
最新推荐文章于 2025-02-19 20:30:36 发布
阅读量2k 收藏 34
点赞数 48
分类专栏： 操作系统原理与Linux实践 文章标签： linux 算法 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49345320/article/details/143156982
版权

文章目录

1. 基于时间片轮转（Round Robin, RR）调度算法模拟

目的：模拟时间片轮转调度算法，理解其工作原理和公平性。

步骤：

  1. 初始化：设定时间片（quantum）的大小，创建一个就绪队列。
  2. 进程到达：将到达的进程按照到达顺序加入到就绪队列中。
  3. 调度：从就绪队列中取出队首进程，运行一个时间片的长度。
  4. 时间片结束：如果进程未完成，将其放回就绪队列的队尾；如果完成，则从队列中移除。
  5. 重复：重复步骤3和4，直到所有进程都完成。
  6. 记录：记录每个进程的等待时间和周转时间。
  7. 流程图：
    在这里插入图片描述
  8. 时间片轮转调度算法模拟C语言：
#include<stdio.h>
#include<stdlib.h>
#define MAX 10   //最大进程数
int Time;   //时间片
int process_amount;  //进程数量
int current_number = 0;   //当前执行的“号码牌”
int index = 0;       //就绪队列要发的“号码牌”，初始值为0
struct PCB
{
    char name[10];   //进程名字
    int arrival_time;   //到达时间
    int service_time;   //服务时间
    int completion_time;   //完成时刻
    int sign_completion;  //标志是否完成调用，0表示没完成，1表示完成
    int remaining_time;  //剩余服务时间
    int number;          //进程在就绪队列里的“号码牌”
}process[MAX];

void input()     //初始化进程的信息
{
    int i;
    printf("请输入时间片：\n");
    scanf("%d",&Time);
    printf("请输入进程名称、到达时间、服务时间：\n");
    for(i = 0; i < process_amount; i ++)
    {
        printf("%d号进程:\n",i+1);
        scanf("%s%d%d",process[i].name,&process[i].arrival_time,&process[i].service_time);
        printf("\n");
        process[i].remaining_time = process[i].service_time;
        process[i].sign_completion = 0;
        process[i].number = 0;       //“号码牌”初始为0
    }
}

void BubbleSort()    //冒泡排序算法对进程抵达时间先后排序
{
    int i,j,n = process_amount;
    for(i = 0; i < n - 1; i++)
        for(j = 0; j < n - 1 - i; j++)
        {
            if(process[j].arrival_time > process[j+1].arrival_time)
            {
                process[n] = process[j+1];
                process[j+1] = process[j];
                process[j] = process[n];

            }
        }
}

void RunProcess()     //时间片轮转调用过程
{
    int time = process[0].arrival_time;      //给当前时间赋初值
    int sum = 0;					//记录完成的进程数
    int i,j;
    while(sum < process_amount)
    {
        for(i = 0;  i < process_amount; i++)
            if(current_number == process[i].number && process[i].sign_completion == 0)
            {
                if(process[i].remaining_time <= Time)    //剩余服务时间少于等于一个时间片
                {
                    time = time + process[i].remaining_time;
                    process[i].sign_completion = 1;
                    process[i].completion_time = time;
                    process[i].remaining_time = 0;
                    printf("%s ",process[i].name);
                    sum++;
                    current_number++;
                    for(j = i + 1; j < process_amount; j++)     //检测后面有没有新进程到达
                        if(process[j].arrival_time <= time && process[j].number == 0)
                        {
                            index++;
                            process[j].number = index;
                        }
                }

                else if(process[i].remaining_time > Time)//剩余服务时间大于一个时间片
                {
                    time = time + Time;
                    process[i].remaining_time -= Time;
                    printf("%s ",process[i].name);
                    current_number++;
                    for(j = i + 1; j < process_amount; j++)    //检测后面有没有新进程到达
                        if(process[j].arrival_time <= time && process[j].number == 0)
                        {
                            index++;
                            process[j].number = index;
                        }
                    index++;
                    process[i].number = index;
                }
            }
        if(index < current_number && sum < process_amount)   // 还有没执行的进程，且没进入就绪队列
        {
            for(i = 0; i <= process_amount; i++)
                if(process[i].sign_completion == 0)
                {
                    time = process[i].arrival_time;
                    index++;
                    process[i].number = index;
                    break;
                }
        }
    }
}

void output()   //打印信息
{
    int i;
    printf("程序名 到达时间 服务时间 完成时间 周转时间  带权周转时间\n");
    for(i = 0; i < process_amount; i++)
    {
        float weight_time = (float)(process[i].completion_time - process[i].arrival_time)/process[i].service_time;
        printf("  %s\t  %d\t   %d\t    %d\t     %d\t\t%.2f\n",process[i].name,process[i].arrival_time,process[i].service_time,
               process[i].completion_time,process[i].completion_time-process[i].arrival_time,weight_time);
    }
}

int main()
{
    int f;
    printf("模拟时间片轮转法实现进程调度\n");
    printf("请输入总进程数：\n");
    scanf("%d",&process_amount);
    input();
    BubbleSort();
    printf("进程运行顺序：\n");
    RunProcess();
    printf("\n");
    output();
    printf("\n");
    system("pause");
    return 0;
}

输出:
在这里插入图片描述

2. 最高优先级优先（Priority Scheduling）调度算法模拟

目的：模拟最高优先级优先调度算法，理解其对进程优先级的处理。

步骤：

  1. 初始化：为每个进程分配一个优先级，创建一个就绪队列。
  2. 进程到达：将到达的进程加入到就绪队列中，并根据优先级排序。
  3. 调度：选择就绪队列中优先级最高的进程执行。
  4. 进程完成：执行完成后，从队列中移除该进程。
  5. 重复：重复步骤3和4，直到所有进程都完成。
  6. 记录：记录每个进程的等待时间和周转时间。
  7. 流程图：
    在这里插入图片描述
  8. 最高优先级优先调度算法模拟 C语言代码实现
#include <stdio.h>
#include <string.h>

#define MAX_PROCESSES 10

typedef struct {
    char name[10];       // 进程名称
    int arrival_time;    // 到达时间
    int service_time;    // 服务时间
    int priority;        // 优先级，数值越小优先级越高
    int completion_time; // 完成时间
    int remaining_time;  // 剩余服务时间
} Process;

Process processes[MAX_PROCESSES];
int process_count; // 实际进程数量

// 函数声明
void input_processes();
void sort_processes_by_priority();
void schedule_processes();
void print_schedule();

int main() {
    printf("模拟最高优先级优先调度算法\n");
    printf("请输入进程数（1-%d）：\n", MAX_PROCESSES);
    scanf("%d", &process_count);
    input_processes();
    sort_processes_by_priority();
    schedule_processes();
    print_schedule();
    return 0;
}

void input_processes() {
    printf("请输入每个进程的名称、到达时间、服务时间和优先级：\n");
    for (int i = 0; i < process_count; ++i) {
        printf("进程 %d:\n", i + 1);
        scanf("%s %d %d %d", processes[i].name, &processes[i].arrival_time, &processes[i].service_time, &processes[i].priority);
        processes[i].completion_time = 0;
        processes[i].remaining_time = processes[i].service_time;
    }
}

void sort_processes_by_priority() {
    // 使用简单的选择排序算法根据优先级排序
    for (int i = 0; i < process_count - 1; ++i) {
        for (int j = 0; j < process_count - i - 1; ++j) {
            if (processes[j].priority > processes[j + 1].priority) {
                Process temp = processes[j];
                processes[j] = processes[j + 1];
                processes[j + 1] = temp;
            }
        }
    }
}

void schedule_processes() {
    int current_time = 0;
    int completed_processes = 0;

    while (completed_processes < process_count) {
        int process_index = -1;
        int highest_priority = 100; // 假设优先级不会超过100

        // 找到当前时间点优先级最高的进程
        for (int i = 0; i < process_count; ++i) {
            if (processes[i].arrival_time <= current_time &&
                processes[i].remaining_time > 0 &&
                processes[i].priority < highest_priority) {
                highest_priority = processes[i].priority;
                process_index = i;
            }
        }

        // 如果当前时间点没有进程可执行，时间前进到下一个进程到达的时间
        if (process_index == -1) {
            int next_arrival_time = 100; // 假设到达时间不会超过100
            for (int i = 0; i < process_count; ++i) {
                if (processes[i].arrival_time > current_time && processes[i].arrival_time < next_arrival_time) {
                    next_arrival_time = processes[i].arrival_time;
                }
            }
            current_time = next_arrival_time;
            continue;
        }

        // 执行进程
        printf("执行进程：%s\n", processes[process_index].name);
        if (processes[process_index].remaining_time > 0) {
            int execute_time = (processes[process_index].remaining_time > 1) ? 1 : processes[process_index].remaining_time;
            processes[process_index].remaining_time -= execute_time;
            current_time += execute_time;
        }

        // 如果进程完成，更新完成时间
        if (processes[process_index].remaining_time == 0) {
            processes[process_index].completion_time = current_time;
            completed_processes++;
        } else {
            // 如果进程未完成，更新其到达时间
            processes[process_index].arrival_time = current_time + 1;
        }
    }
}

void print_schedule() {
    printf("进程名\t到达时间\t服务时间\t优先级\t完成时间\n");
    for (int i = 0; i < process_count; ++i) {
        printf("%s\t%d\t\t%d\t\t%d\t\t%d\n", processes[i].name, processes[i].arrival_time, processes[i].service_time, processes[i].priority, processes[i].completion_time);
    }
}

输出：
在这里插入图片描述

3. 先来先服务（FCFS）调度算法模拟

目的：模拟先来先服务调度算法，理解其简单性和公平性。

步骤：

  1. 初始化：创建一个就绪队列。
  2. 进程到达：将到达的进程按照到达顺序加入到就绪队列中。
  3. 调度：从就绪队列中取出队首进程执行。
  4. 进程完成：执行完成后，从队列中移除该进程。
  5. 重复：重复步骤3和4，直到所有进程都完成。
  6. 记录：记录每个进程的等待时间和周转时间。
  7. 流程图：
    在这里插入图片描述
  8. FCFS调试算法模拟 C语言代码实现
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_PROCESSES 10

typedef struct {
    char name[10];       // 进程名称
    int arrival_time;    // 到达时间
    int service_time;    // 服务时间
    int completion_time; // 完成时间
    int waiting_time;    // 等待时间
    int turnaround_time; // 周转时间
} Process;

Process processes[MAX_PROCESSES];
int process_count; // 实际进程数量

void input_processes() {
    printf("请输入进程数（1-%d）：\n", MAX_PROCESSES);
    scanf("%d", &process_count);
    printf("请输入每个进程的名称、到达时间和服务时间：\n");
    for (int i = 0; i < process_count; ++i) {
        printf("进程 %d:\n", i + 1);
        scanf("%s %d %d", processes[i].name, &processes[i].arrival_time, &processes[i].service_time);
        processes[i].completion_time = 0;
        processes[i].waiting_time = 0;
        processes[i].turnaround_time = 0;
    }
}

void schedule_processes() {
    int current_time = 0;
    int completed_processes = 0;

    // 按到达时间排序
    for (int i = 0; i < process_count; ++i) {
        for (int j = i + 1; j < process_count; ++j) {
            if (processes[i].arrival_time > processes[j].arrival_time) {
                Process temp = processes[i];
                processes[i] = processes[j];
                processes[j] = temp;
            }
        }
    }

    for (int i = 0; i < process_count; ++i) {
        if (processes[i].arrival_time > current_time) {
            current_time = processes[i].arrival_time;
        }
        processes[i].waiting_time = current_time - processes[i].arrival_time;
        current_time += processes[i].service_time;
        processes[i].completion_time = current_time;
        processes[i].turnaround_time = processes[i].completion_time - processes[i].arrival_time;
    }
}

void print_schedule() {
    printf("进程名\t到达时间\t服务时间\t等待时间\t周转时间\t完成时间\n");
    for (int i = 0; i < process_count; ++i) {
        printf("%s\t%d\t\t%d\t\t%d\t\t%d\t\t%d\n", processes[i].name, processes[i].arrival_time, processes[i].service_time, processes[i].waiting_time, processes[i].turnaround_time, processes[i].completion_time);
    }
}

int main() {
    input_processes();
    schedule_processes();
    print_schedule();
    return 0;
}

输出：
在这里插入图片描述

操作系统实验：在linux下用c语言模拟进程调度算法程序
m0_68165821的博客
11-15 1285
进程每执行一次，进程需要的时间片数减1、该进程的优先数减3。进程执行时，每运行一个时间片，进程还需要的时间片数减1，运行进程占用处理机的时间片数加1，然后比较占用CPU的时间片数是否与该进程的轮转时间片数相等，若相等则说明已达到轮转时间，应将现运行的进程排列就绪队列的末尾，调度队列上的首进程运行，且改变它们的进程状态，直至所有进程完成各自的时间片。（4）为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。
linux下进程调度算法实验,Linux下进程调度算法的模拟实现.doc
weixin_35529551的博客
05-08 1389
Linux下进程调度算法的模拟实现枣 庄 学 院信息科学与工程学院课程设计任务书题目： Linux下进程调度算法的模拟实现学 生1：学 生2：学 生3：专 业： 计算机应用技术课 程： 操作系统指导教师： 职称： 副教授完成时间： 2015年 12月----2016 年 1月枣庄学院信息科学与工程学院...
【算法】时间片轮转调度算法：进程调度之公
INS_1023的博客
02-19 1001
在计算机操作系统中，进程调度是确保CPU资源高效、公平分配的关键机制之一。时间片轮转调度算法（Round-Robin，简称RR）作为一种经典且广泛应用的调度算法，以其公平性和简单性在多任务处理系统中发挥着重要作用。本文将深入介绍时间片轮转调度算法的基本原理、工作流程、具体案例，以及优化策略。时间片轮转调度算法是一种抢占式的进程调度算法，它将CPU时间分割成固定长度的时间片（或称时间量），并按照进程到达就绪队列的顺序，循环分配CPU给每个进程执行。
linux模拟进程调度算法,linux下进程调度算法的模拟实现.doc
weixin_34511754的博客
04-28 332
linux下进程调度算法的模拟实现.doc还剩19页未读，继续阅读下载文档到电脑，马上远离加班熬夜！亲，喜欢就下载吧，价低环保！内容要点：223.时间片轮转算法运行结果4. 实验过程中出现的问题及解决方法在这次课程设计中遇到了不少问题，但都被解决了，对我们来说是一个不小的收获，在这个过程中，出现了编程出错问题，经过我们不断地调试，最后终于能够正常运行，这极大地提升了我们的自信心。5. 总结通过这次...
linux下进程调度模拟程序,进程调度算法在Linux下的模拟实现
weixin_36286464的博客
05-11 424
{ printf("\n the number of process No.%d:\n",i);p=getpch(PCB);printf("\n enter the name of process:");scanf("%s",p->name);printf("\n enter the prior number of process:");scanf("%d",&p->super...
linux模拟进程调度,Linux进程调度模拟3
weixin_32388647的博客
05-03 241
/*模拟LINUX进程调度双队列实现静态优先级算法和时间片轮转算法，当进程时间片用完时主动释放CPU的控制权运行队列里的进程放到睡眠队列里，让低优先级进程先运行,当一轮调度用完时重新分配时间片，从睡眠队列里唤醒睡眠的队列*///在下一个版本中将入互斥锁，动态优先级以及优先级逆转#include #include #include#define NUM 6#define RUN 1#define ...
时间片轮转算法和优先级调度算法模拟实现（C）
Qxxchampion的博客
05-17 3537
时间片轮转算法和优先级调度算法模拟实现（C语言）代码 #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct node { char name[10]; /*进程标识符*/ int prio; /*进程优先数*/ int round; /*进程时间轮转时间片*/ int cputime; /*进程占用CPU时间*/ int needtime;
操作系统-模拟进程调度（时间片轮转调度算法，高优先级调度算法）C语言实现-实验报告
11-29
本文档是一份关于操作系统进程调度的实验报告，详细阐述了如何使用C语言实现时间片轮转调度算法和高优先级调度算法。在操作系统中，进程调度是一个核心功能，它负责按照一定的策略在多个可执行进程之间分配处理器...
操作系统-模拟进程的调度（时间片轮转算法，高优先级调度算法）C实现
11-29
在操作系统中，进程调度是核心功能之一，它负责决定哪个进程获得...在学习和实践操作系统的过程中，通过编写类似的时间片轮转和高优先级调度算法，可以加深对操作系统工作原理的理解，并掌握C语言在系统编程中的应用。
Java模拟最短作业优先、时间片轮转、最高响应比和先来先服务进程调度算法
06-21
Java模拟最短作业优先、时间片轮转、最高响应比和先来先服务进程调度算法 rar中有四种算法和俩个对进程用时和周转时间制图的java源代码，另外有jcommon-1.0.23.jar和jfreechart-1.0.19.jar俩个制图包
操作系统进程与存储管理调度算法实验-FCFS、优先级、时间片轮转、SJF、HRN及其分区回收算法的实现与演示
最新发布
03-11
本文档详细介绍了三次关于操作系统的课程实验，涵盖进程调度（含FCFS、优先级、时间片轮转）、作业调度（含短作业优先、高响应比优先）和存储管理（含首次适应、循环首次适应、最佳适应、最坏适应及其分区回收）的...
先来先服务进程调度算法模拟
03-28
windows下c++ 1）用C语言（或其它语言，如Java）实现对N个进程采用某种进程调度算法（如 动态优先权调度）的调度。 （2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段：  进程标识数ID。  进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。  进程已占用CPU时间CPUTIME。  进程还需占用的CPU时间ALLTIME。当进程运行完毕时，ALLTIME变为0。  进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片 后，进程将进入阻塞状态。  进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME个 时间片后，将转换成就绪状态。  进程状态STATE。  队列指针NEXT，用来将PCB排成队列。 （3）优先数改变的原则：  进程在就绪队列中呆一个时间片，优先数增加1。  进程每运行一个时间片，优先数减3。 （4）为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显 示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。
采用时间片轮转算法的进程调度程序
09-23
1)每一个进程有一个PCB，其内容可以根据具体情况设定。 2)可以在界面设定的互斥资源（包括两种：输入设备与输出设备）的数目 3)进程数、进入内存时间、要求服务时间可以在界面上进行设定 4)进程之间存在一定的同步与互斥关系，可以通过界面进行设定，其表示方法如下：进程的服务时间由三段组成：I2C10O5（表示进程的服务时间由2个时间片的输入，10个时间片的计算，5个时间片的输出） 进程间的同步关系用一个段表示：W2，表示该进程先要等待P2进程执行结束后才可以运行因此，进程间的同步与互斥关系、服务时间可以统一用四段表示为：I2C10O5W2 5)可以在运行中显示各进程的状态：就绪、阻塞、执行 6)采用可视化界面，可在进程调度过程中随时暂停调度，查看当前进程的状态以及相应的阻塞队列 7)具有一定的数据容错性
时间片轮转算法和优先级调度算法C语言模拟实现收藏.doc
09-25
时间片轮转算法和优先级调度算法C语言模拟实现收藏.doc
基于Linux的先来先服务
12-20
在C++开发环境下利用所提供的clock（）函数，实现先来先服务算法的模拟；可以用一个空循环或其他操作来模拟一个作业量，建议输入的作业量都在100－1000为宜。通过程序运行结果所显示的“作业号、作业量、提交时间、开始运行时间、执行时间、等待时间”的值来体现先来先服务原则。帮助加深了解作业调度的工作。
操作系统进程调度算法（先来先服务，短作业优先算法（SJF））linux下（附源码）
12-24
FCFS是最简单的调度算法，既可以用作作业调度，也可以用作进程调度 这种算法优先考虑系统中等待时间最长的作业（进程），而不管作业所需执行时间长短， 做法是从后备队列中选择几个最先进入该队列的作业，将它们调入内存，为它们分配资源和创建进程，然后放入就绪队列 进程
进程调度模拟：时间片轮转与优先级法深入解析
时间片轮转和优先级法是操作系统中进程调度的两种基本算法。在进程模拟调度的设计中，这两种算法常被用于设计和实现进程调度的模拟程序，以便更好地理解进程调度在实际操作系统中的工作原理。下面将详细介绍这两种...
时间片轮转算法和优先级调度算法模拟实现
weixin_30735745的博客
10-29 3517
实验三时间片轮转算法和优先级调度算法模拟实现 一、 实验任务 1. 设计进程控制块PCB的结构，通常应包括如下信息： 进程名、进程优先数（或轮转时间片数）、进程已占用的CPU时间、进程到完成还需要的时间、进程的状态、当前队列指针等。 2.编写两种调度算法程序： 优先级调度算法 时间片轮转调度算法 3. 按要求输出结果。 二、实验目的 1. 加深理解有关进程控制块、进程队列等概念...
linux操作系统实验-进程调度实验
weixin_41714523的博客
11-29 1994
通过对作业或进程调度算法模拟设计，进一步加深对作业或进程调度算法的理解，通过计算平均周转时间和带权平均周转时间，进一步加深对算法的评价方法的理解。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

浪里个浪的1024

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

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

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

打赏作者

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

抵扣说明：

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

余额充值