Java-进程调度算法

文章目录

  • 为什么要设置进程调度算法?
  • 分类
    • 1. 先进先出(FIFO)算法
      • 优缺点
      • FIFO代码示例
    • 2. 短作业优先(SJF)算法
      • 优缺点
      • 示例代码
    • 3. 优先级算法(Priority scheduling)
      • 优缺点
      • 示例代码
    • 4. 时间片轮转算法
      • 优缺点
      • 示例
  • 各个算法的区别
  • 总结

热烈欢迎各位大佬的到来:大哥天,大哥地,大哥是我的天地。
祝大哥,吃不愁穿不愁,不住平房住高楼

在这里插入图片描述

Java进程调度算法是计算机操作系统中非常重要的一个方面,它决定了在多个进程同时运行时,哪些进程将获得CPU时间片,以及执行时间如何分配。

为什么要设置进程调度算法?

Java中设置进程调度算法是为了有效地管理和分配CPU资源,以提高系统的性能和响应能力。

进程调度算法的选择可以根据不同的需求来进行,例如最短剩余时间优先算法(Shortest Remaining Time First, SRTF)可以保证短作业优先得到更快的响应时间,而轮转调度算法(Round Robin)可以平均分配CPU时间片,保证每个线程或进程都有机会执行。

通过设置合适的进程调度算法,可以避免线程或进程之间的饥饿情况,提高系统的吞吐量和效率。同时,进程调度算法也需要考虑到公平性、响应时间、吞吐量等方面的需求,以满足不同场景下的要求。

分类

Java进程调度算法可以基于不同的策略进行实现,包括但不限于以下几种:

1. 先进先出(FIFO)算法

这是最简单的进程调度算法,它按照进程到达时间的先后顺序依次分配CPU时间片。但是,它忽略了进程的优先级和执行时间,可能会导致长时间等待的进程被阻塞,进程执行效率低下。

优缺点

优点:

  • 实现简单,易于理解和实现。
  • 不会产生死锁,因为每个进程都按照它们进入系统的顺序依次执行。
  • 在处理一些短时间的进程时,可以保证较好的响应时间。

缺点:

  • 无法处理优先级,每个进程都被视为同等重要,可能导致低优先级进程被长时间忽略。
  • 无法考虑进程的执行时间,可能会导致某些进程长时间占用CPU,而其他进程则得不到足够的调度时间。
  • 在处理长时间运行的进程时,平均等待时间较长。

综上所述,FIFO算法在某些特定场景下是一种很好的选择,但在处理复杂的进程调度问题时,可能需要更为高级的算法来保证所有进程都能够公平地获得调度时间。

FIFO代码示例

以下是使用Java编写的一个简单的先进先出(FIFO)算法的进程调度代码示例:

import java.util.LinkedList;
import java.util.Queue;

public class ProcessSchedulerFIFO {
    private Queue<Process> queue;

    public ProcessSchedulerFIFO() {
        queue = new LinkedList<Process>();
    }

    public void addProcess(Process process) {
        queue.offer(process);
    }

    public void run() {
        while (!queue.isEmpty()) {
            Process process = queue.poll();
            process.execute(); // 执行进程
        }
    }

    public static void main(String[] args) {
        ProcessSchedulerFIFO scheduler = new ProcessSchedulerFIFO();

        // 构造多个进程示例
        Process p1 = new Process("Process 1", 10);
        Process p2 = new Process("Process 2", 5);
        Process p3 = new Process("Process 3", 8);

        scheduler.addProcess(p1);
        scheduler.addProcess(p2);
        scheduler.addProcess(p3);

        scheduler.run();
    }
}

// 定义Process类
class Process {
    private String name;
    private int executionTime;

    public Process(String name, int executionTime) {
        this.name = name;
        this.executionTime = executionTime;
    }

    public void execute() {
        System.out.println("Executing process " + name + " for " + executionTime + " seconds.");
        try {
            Thread.sleep(executionTime * 1000); // 模拟进程执行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中,我们创建了一个ProcessSchedulerFIFO类来实现先进先出算法。addProcess()方法将待执行的进程加入到队列中,run()方法按照队列的先进先出顺序依次执行每个进程。

我们还创建了一个Process类代表实际的进程。在execute()方法中,我们模拟了进程的执行,使用Thread.sleep()函数使线程休眠指定的时间。

在main()方法中,我们创建了3个Process实例并将它们添加到ProcessSchedulerFIFO队列中。最后,运行ProcessSchedulerFIFO的run()方法以按照先进先出顺序执行所有进程。

2. 短作业优先(SJF)算法

短作业优先(SJF)算法是一种基于执行时间的进程调度算法,这种调度算法考虑了每个进程的执行时间,对执行时间最短的进程优先进行调度。它可以最小化平均等待时间和平均周转时间,但可能导致长时间等待的进程被阻塞,而且需要提前准确评估进程的执行时间。

优缺点

它的主要优点是最小化平均等待时间和平均周转时间,因为它将最短的作业分配给CPU执行。以下是Java进程使用SJF算法的优缺点:

优点:

  • 最小化平均等待时间和平均周转时间,因为短作业被优先执行。
  • 对于长时间的作业,SJF算法可以保证不会一直等待,因为短作业会在它们之前被执行。

缺点:

  • SJF算法无法预测未来进程的执行时间,因此可能会出现长时间的等待时间。如果有一个长时间的作业在队列前面,那么后面的短作业就要等待很长时间才能得到执行。
  • SJF算法需要知道每个进程的执行时间,但在实际应用中很难预测。如果没有准确的执行时间信息,SJF算法就无法正常工作。
  • 如果有很多短作业,SJF算法会很好地处理它们,但对于长时间的作业,会有较长的等待时间。这意味着,SJF算法并不一定是适用于所有情况的最佳算法。

示例代码

以下是使用短作业优先算法的Java代码示例:

import java.util.*;

public class SJFProcessScheduler {

    public static void main(String[] args) {

        Scanner input = new Scanner(System.in);

        System.out.print("Enter the number of processes: ");
        int n = input.nextInt();

        int[] arrivalTime = new int[n];
        int[] burstTime = new int[n];
        int[] waitingTime = new int[n];
        int[] turnaroundTime = new int[n];
        boolean[] visited = new boolean[n];

        for (int i = 0; i < n; i++) {
            System.out.print("Enter the arrival time of process " + (i + 1) + ": ");
            arrivalTime[i] = input.nextInt();
            System.out.print("Enter the burst time of process " + (i + 1) + ": ");
            burstTime[i] = input.nextInt();
        }

        int totalWaitingTime = 0;
        int totalTurnaroundTime = 0;
        int totalProcessed = 0;
        int currentTime = 0;

        while (totalProcessed < n) {
            int shortestJobIndex = -1;
            int shortestJobTime = Integer.MAX_VALUE;
            for (int i = 0; i < n; i++) {
                if (!visited[i] && burstTime[i] < shortestJobTime && arrivalTime[i] <= currentTime) {
                    shortestJobTime = burstTime[i];
                    shortestJobIndex = i;
                }
            }
            if (shortestJobIndex == -1) {
                currentTime++;
            } else {
                waitingTime[shortestJobIndex] = currentTime - arrivalTime[shortestJobIndex];
                turnaroundTime[shortestJobIndex] = waitingTime[shortestJobIndex] + burstTime[shortestJobIndex];
                totalWaitingTime += waitingTime[shortestJobIndex];
                totalTurnaroundTime += turnaroundTime[shortestJobIndex];
                visited[shortestJobIndex] = true;
                totalProcessed++;
                currentTime += burstTime[shortestJobIndex];
            }
        }

        double averageWaitingTime = (double) totalWaitingTime / n;
        double averageTurnaroundTime = (double) totalTurnaroundTime / n;

        System.out.println("Average waiting time: " + averageWaitingTime);
        System.out.println("Average turnaround time: " + averageTurnaroundTime);
    }
}

在这个示例中,输入包括每个进程的到达时间和执行时间。然后,计算出每个进程的等待时间和周转时间,并计算出平均等待时间和平均周转时间。该示例使用布尔数组来跟踪进程是否已被访问,以避免在同一时间执行多个进程。

3. 优先级算法(Priority scheduling)

该算法根据每个进程的优先级,对具有更高优先级的进程进行调度,以保证其获得更多的CPU时间片。但是,由于可能存在优先级反转问题,因此需要额外的机制来解决这个问题。

优缺点

优先级调度算法是一种根据优先级为进程分配处理器的算法。以下是Java进程使用优先级算法的优缺点:

优点:

  • 优先级调度算法可以根据进程的重要性分配处理器。优先级越高的进程会优先获得CPU时间,从而提高系统的响应速度和效率。
  • 这种算法可以满足实时系统的需求,例如控制系统、飞行模拟器和医疗设备等其它高优先级进程的需求。

缺点:

  • 如果进程的优先级不平衡,或者有一个进程的优先级极高,那么其他进程可能会得不到处理器时间。这可能会导致饥饿问题(Starvation),即某个进程永远无法获得CPU时间。
  • 如果发生优先级反转(Priority inversion),那么一些低优先级的进程可能会抢占高优先级进程的资源,比如锁。这可能会导致低优先级进程的执行时间非常长,从而降低了系统的响应速度和效率。
  • 在某些情况下,优先级调度算法可能无法满足进程的响应时间需求。这是因为某些高优先级进程可能在长时间内持有处理器时间,而低优先级进程需要等待很长时间才能获得CPU时间。

示例代码

以下是一个使用优先级算法的Java代码示例:

import java.util.Comparator;
import java.util.PriorityQueue;

public class PriorityScheduler {
    public static void main(String[] args) {
        // 定义一个进程类
        class Process {
            int pid; // 进程ID
            int priority; // 进程优先级

            public Process(int pid, int priority) {
                this.pid = pid;
                this.priority = priority;
            }
        }

        // 定义一个按照优先级排序的队列
        PriorityQueue<Process> queue = new PriorityQueue<>(new Comparator<Process>() {
            @Override
            public int compare(Process p1, Process p2) {
                return p2.priority - p1.priority;
            }
        });

        // 添加一些进程到队列中
        queue.offer(new Process(1, 5));
        queue.offer(new Process(2, 1));
        queue.offer(new Process(3, 3));
        queue.offer(new Process(4, 2));
        queue.offer(new Process(5, 4));

        // 取出队列中的进程并执行
        while (!queue.isEmpty()) {
            Process p = queue.poll();
            System.out.println("Process " + p.pid + " is running with priority " + p.priority);
            // 等待一段时间
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

在这个例子中,我们使用优先级优先的原则从优先级最高的进程开始执行,直到队列为空。在真实的操作系统中,优先级调度算法有更复杂的实现,通常还会考虑到各种因素,如时间片轮转、多级反馈队列等。

4. 时间片轮转算法

这是最常用的调度算法之一,它将所有进程分配相同长度的时间片,然后按顺序调度进程。每个进程在时间片结束时暂停,等待下一个时间片。这种算法可以确保公平性,并且不需要估计进程的执行时间。

优缺点

时间片轮转算法其优缺点如下:

优点:

  • 公平性:每个进程都有一个相同的时间片,可以公平地分配CPU资源。

  • 响应时间短:对于需要快速响应的进程,时间片轮转算法可以很快地将其放到CPU上运行。

  • 避免饥饿:由于每个进程只执行一段时间,因此无论优先级如何,每个进程都有机会被调度执行。

缺点:

  • 时间片大小的选择:如果时间片太小,会导致频繁的上下文切换,影响系统的性能;如果时间片太大,会导致进程响应时间变长。

  • 大量繁忙的进程:当系统中存在大量繁忙的进程时,时间片轮转算法可能无法有效利用CPU资源,因为每个进程只能运行一个时间片,而在时间片过期之前,其他进程无法获得CPU时间。

  • 不适合长时间运行的进程:对于需要长时间运行的进程,时间片轮转算法可能无法提供足够的CPU时间,因为进程只能在时间片内执行一定量的工作。

综上所述,时间片轮转算法是一种简单而公平的进程调度算法,适用于大多数通用的操作系统。但是,对于某些特定的应用场景,可能需要其他的进程调度算法来更好地支持应用程序的性能和稳定性。

示例

下面是Java进程使用时间片轮转算法的简单示例代码:

import java.util.LinkedList;
import java.util.Queue;

public class TimeSliceScheduler {
    // 定义时间片大小
    private static final int TIME_SLICE = 2;

    // 定义进程队列
    private Queue<Process> queue;

    // 构造函数初始化进程队列
    public TimeSliceScheduler() {
        queue = new LinkedList<>();
        queue.offer(new Process("P1", 6));
        queue.offer(new Process("P2", 5));
        queue.offer(new Process("P3", 4));
        queue.offer(new Process("P4", 3));
    }

    // 时间片轮转算法
    public void schedule() {
        while (!queue.isEmpty()) {
            // 取出队首进程
            Process process = queue.poll();

            // 运行进程
            process.run(TIME_SLICE);

            // 如果进程还未完成,则加入队列末尾
            if (!process.isFinished()) {
                queue.offer(process);
            }
        }
    }

    // 测试
    public static void main(String[] args) {
        TimeSliceScheduler scheduler = new TimeSliceScheduler();
        scheduler.schedule();
    }
}

// 进程类
class Process {
    private String name;  // 进程名
    private int total;    // 进程需要的时间
    private int executed; // 进程已经执行的时间

    public Process(String name, int total) {
        this.name = name;
        this.total = total;
        this.executed = 0;
    }

    // 运行进程
    public void run(int timeSlice) {
        int remaining = total - executed;
        int time = Math.min(timeSlice, remaining);
        executed += time;
        System.out.println("Process " + name + " executed " + time + " units (total " + executed + " units).");
    }

    // 判断进程是否执行完成
    public boolean isFinished() {
        return executed >= total;
    }
}

上面的代码使用Java语言实现了基本的时间片轮转算法。其中,使用一个进程队列来存储所有需要执行的进程,每次从队首取出一个进程并运行一个时间片,如果进程未完成,则重新加入队列末尾,直到队列为空为止。由于示例中每个进程的执行时间较短,因此示例只运行了一轮,实际应用中可能需要多轮执行才能完成所有进程的运行。

各个算法的区别

对四种算法从不同的维度进行了对比:
在这里插入图片描述

在Java中,我们可以通过java.util.concurrent包中的Executor框架执行进程调度。线程池和任务队列是实现Java进程调度算法的关键组件。线程池管理线程的数量和可用性,并且最小化线程创建的开销。任务队列则允许我们安排任务的执行顺序,例如FIFO或优先级排序。

总结

总而言之,Java进程调度算法是计算机操作系统中非常重要的方面,可以通过不同的调度算法实现。每种算法都有其优缺点,需要根据具体情况进行选择和使用。在Java中,我们可以使用线程池和任务队列来实现进程调度。

再次热烈欢迎各位大佬的到来:大哥天,大哥地,大哥是我的天地。
祝大哥,吃不愁穿不愁,不住平房住高楼

在这里插入图片描述
如果文章合您的胃口,麻烦您动动小手指给小弟来个一键三连,小弟万分感谢。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/85770.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

Midjourney API 国内申请及对接方式

在人工智能绘图领域&#xff0c;想必大家听说过 Midjourney 的大名吧&#xff01; Midjourney 以其出色的绘图能力在业界独树一帜。无需过多复杂的操作&#xff0c;只要简单输入绘图指令&#xff0c;这个神奇的工具就能在瞬间为我们呈现出对应的图像。无论是任何物体还是任何风…

Docker容器与虚拟化技术:Docker consul 实现服务注册与发现

目录 一、理论 1.Docker consul 二、实验 1.consul部署 2. consul-template部署 三、总结 一、理论 1.Docker consul &#xff08;1&#xff09;服务注册与发现 服务注册与发现是微服务架构中不可或缺的重要组件。起初服务都是单节点的&#xff0c;不保障高可用性&…

解决Linux虚拟机IP无法显示的问题

目录 问题&#xff1a; 两种解决方案&#xff0c;供大家选择使用哦。 第一种解决办法&#xff1a; 第二种解决办法&#xff1a; 1、查看ens33网卡的配置 2、修改文件 扩展&#xff1a; 问题&#xff1a; Linux命令 ip a 查看ip时&#xff0c;无法显示IP的解决办法。 两…

lnmp(docker)

1. 建立工作目录 [rootdocker ~]# mkdir /opt/nginx [rootdocker ~]# cd /opt/nginx [rootdocker nginx]# rz -E rz waiting to receive. #上传 nginx 安装包 nginx-1.12.0.tar.gz[rootdocker nginx]# rz -E rz waiting to receive. #上传 wordpress 服务包 wordpress-4.9.4-z…

vscode远程调试

安装ssh 在vscode扩展插件搜索remote-ssh安装 如果连接失败&#xff0c;出现 Resolver error: Error: XHR failedscode 报错&#xff0c;可以看这篇帖子vscode ssh: Resolver error: Error: XHR failedscode错误_阿伟跑呀的博客-CSDN博客 添加好后点击左上角的加号&#xff0…

Python功能制作之简单的音乐播放器

需要导入的库&#xff1a; pip install PyQt5 源码&#xff1a; import os from PyQt5.QtCore import Qt, QUrl from PyQt5.QtGui import QIcon, QPixmap from PyQt5.QtMultimedia import QMediaPlayer, QMediaContent from PyQt5.QtWidgets import QApplication, QMainWind…

剪枝基础与实战(1): 概述

本文介绍基于L1正则化的剪枝原理,并以VGG网络进行实战说明。将从零详细介绍模型训练、稀疏化、剪枝、finetune的全过程,提供详细的源码及说明,有助于对剪枝的熟练掌握,后续也会对yolov8进行剪枝的介绍。 论文: Learning Efficient Convolutional Networks through Network …

激活函数总结(十七):激活函数补充(PELU、Phish)

激活函数总结&#xff08;十七&#xff09;&#xff1a;激活函数补充 1 引言2 激活函数2.1 Parametric Exponential Linear Unit&#xff08;PELU&#xff09;激活函数2.2 Phish激活函数 3. 总结 1 引言 在前面的文章中已经介绍了介绍了一系列激活函数 (Sigmoid、Tanh、ReLU、…

SAP S/4HANA 2022:MRP Live 和 Classic MRP新的增强BADI

翻译一篇&#xff0c;原文在SAP BLOG中如下&#xff1a; 目录 前言通过 BADIs 操作 MRP 元素新的 BadI PPH_SUPPLY_DEMAND_LISTBADI PPH_SUPPLY_DEMAND_LIST 的示例实现结论 前言 SAP S/4HANA 引入了新的 BADI PPH_SUPPLY_DEMAND_LIST&#xff0c;它允许我们在MRP Live 和 C…

2023.8.19-2023.8.XX 周报【人脸3D+虚拟服装方向基础调研-Cycle Diffusion\Diffusion-GAN\】更新中

学习目标 1. 这篇是做diffusion和gan结合的&#xff0c;可以参照一下看看能不能做cyclegan的形式&#xff0c;同时也可以调研一下有没有人follow这篇论文做了类似cyclegan的事情 Diffusion-GAN论文精读https://arxiv.org/abs/2206.02262 2. https://arxiv.org/abs/2212.06…

[足式机器人]Part3机构运动微分几何学分析与综合Ch03-1 空间约束曲线与约束曲面微分几何学——【读书笔记】

本文仅供学习使用 本文参考&#xff1a; 《机构运动微分几何学分析与综合》-王德伦、汪伟 《微分几何》吴大任 Ch01-4 平面运动微分几何学 3.1 空间曲线微分几何学概述3.1.1 矢量表示3.1.2 Frenet标架 连杆机构中的连杆与连架杆构成运动副&#xff0c;该运动副元素的特征点或特…

通过cpolar在外远程查看家里内网监控

通过cpolar在外远程查看家里内网监控 文章目录 通过cpolar在外远程查看家里内网监控前言1. 在cpolar官网预留一个空白隧道2. 完成空白数据隧道&#xff0c;生成地址3. 设置空白隧道的出口4. 空白数据隧道的出口设置5. 获取公网地址6. 打开本地电脑“远程桌面”7. 打开Windows自…

三星Galaxy S23与iPhone 15的对比分析:谁会胜出?

三星Galaxy S23与iPhone 15的对决将于下个月进入高潮,这将是今年智能手机中最大的一场较量。毕竟,这是两家领先的移动设备制造商的旗舰手机。他们的手机的比较将在很大程度上决定谁能获得最佳手机的称号。 我们已经知道有利于三星Galaxy S23的情况,该产品自春季以来一直在推…

算法 | 活用双指针完成复写零操作

Problem: 1089. 复写零 文章目录 题目解析算法原理分析找到最后一个复写的位置从后往前进行复写操作 代码展示 题目解析 首先我们来分析一下本题的题目意思 可以看到题目中给到了一个数组&#xff0c;意思是让我们将数组中的零元素都复写一遍&#xff0c;然后将其余的元素向后平…

jmeter-results-detail-report_new.xsl文件设置dateReport

<!-- Defined parameters (overrideable) <td bgcolor"#ff00ff"> --> <xsl:param name"showData" select"y"/> <xsl:param name"titleReport" select"测试报告"/> <xsl:param name&…

从零实现深度学习框架——Transformer从菜鸟到高手(二)

引言 &#x1f4a1;本文为&#x1f517;[从零实现深度学习框架]系列文章内部限免文章&#xff0c;更多限免文章见 &#x1f517;专栏目录。 本着“凡我不能创造的&#xff0c;我就不能理解”的思想&#xff0c;系列文章会基于纯Python和NumPy从零创建自己的类PyTorch深度学习框…

Electron学习2 使用Electron-vue和Vuetify UI库

Electron学习2 使用Electron-vue和Vuetify UI库 一、Electron-vue简介二、安装yarn三、创建Electron-vue项目1. 关于 electron-builder2. 安装脚手架3. 运行4. 打包应用程序 四、background.js说明1. 引入模块和依赖&#xff1a;2. 注册协议&#xff1a;3. 创建窗口函数&#x…

通过springMVC拦截器进行后台统一校验

通过springMVC拦截器统一解析token&#xff0c;判断是否有效。可以对请求进行前置或后置处理 /*** 配置拦截器*/ public class TokenInterceptor implements HandlerInterceptor {Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response,…

Commonjs和Es6语法规范的理解

ES6 module和CommonJS到底有什么区别&#xff1f; “ES6 module是编译时加载&#xff0c;输出的是接口&#xff0c;CommonJS运行时加载&#xff0c;加载的是一个对象” 这里的“编译时”是什么意思&#xff1f;和运行时有什么区别&#xff1f;“接口”又是什么意思&#xff1f;…

2023.08.20 学习周报

文章目录 摘要文献阅读1.题目2.现有问题3.解决方案4.本文贡献5.方法5.1 利用长短期记忆网络学习时空演化特征5.2 构建用于气象辅助信息编码的堆叠自编码器5.3 使用多任务学习发现全市通用模式5.4 模型 6. 实验6.1 数据集6.2 实验设置6.3 实验结果 7.结论8.展望 大气污染物传输总…