Java线程常用调度算法与应用

简介: Java线程常用调度算法与应用

1 调度算法应用

调度算法常见于操作系统中,因为系统资源有限,当有多个进程(或多个进程发出的请求)要使用这些资源时,就必须按照一定的原则选择进程(请求)来占用资源。这就是所谓的调度。在现实生活中也是一样,比如会议室的占用。


CPU资源调度

云计算资源调度

容器化Docker编排与调度


2 先来先服务(FCFS)

2.1 概念

先来先服务,很好理解,就是按照服务提交申请的顺序,依次执行。讲究先来后到。


2.2 实现

定义一个Task类作为任务实例,BlockingQueue作为服务队列


package com.oldlu.schedule;

package com.oldlu.schedule;
/**
 * 任务类
 */
public class Task {
    //任务名称
    private String name;
    //任务提交的时间
    private Long addTime;
    //任务的执行时间长短
    private int servTime;
    public Task(String name, int servTime) {
        this.name = name;
        this.servTime = servTime;
        this.addTime = System.currentTimeMillis();
    }
    public void execute() {
        try {
            // !重点:执行时睡眠,表示该任务耗时servTime毫秒
            Thread.currentThread().sleep(servTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(String.format("execute:name=%s,addTime=%s,servTime=%s", name,
addTime, servTime));
    }
}
package com.oldlu.schedule;
import java.util.Random;
import java.util.concurrent.LinkedBlockingQueue;
public class FCFS {
    public static void main(String[] args) throws InterruptedException {
        //阻塞队列,FCFS的基础
        final LinkedBlockingQueue<Task> queue = new LinkedBlockingQueue(5);
        //服务线程,任务由该线程获取和执行
        new Thread(new Runnable(){
            @Override
            public void run() {
                while (true) {
                    try {
                        queue.take().execute();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
        //向队列中放入一个任务
        for (int i = 0; i < 5; i++) {
            System.out.println("add task:"+i);
            queue.put(new Task("task"+i,new Random().nextInt(1000)));
        }
    }
}

3)结果分析

add按顺序放入,时间有序

execute也按时间顺序执行,而不管后面的servTime,也就是不管执行任务长短,先来先执行


2.4 优缺点

多应用于cpu密集型任务场景,对io密集型的不利。

时间相对均衡的业务可以排队处理,比如现实中排队打卡进站。

如果业务需要依赖大量的外部因素,执行时间片长短不一,FCFS算法不利于任务的整体处理进度,可能会因

为一个长时间业务的阻塞而造成大量等待。


3 短作业优先 (SJF)

3.1 概念

执行时间短的优先得到资源。即执行前申报一个我需要占据cpu的时间,根据时间长短,短的优先被调度。我不占

时间所以我先来。


3.2 实现

使用TreeMap可以实现优先级的任务排序。

package com.oldlu.schedule;
import javax.swing.text.html.parser.Entity;
import java.util.Map;
import java.util.Random;
import java.util.TreeMap;
public class SJF {
    public static void main(String[] args) throws InterruptedException {
        //有序Map,将服务时间作为key排序
        final TreeMap<Integer,Task> treeMap = new TreeMap();
        //向队列中放入5个任务
        for (int i = 0; i < 5; i++) {
            System.out.println("add task:"+i);
            int servTime = new Random().nextInt(1000);
            //注意,key是servTime,即执行预估时间
            treeMap.put(servTime,new Task("task"+i,servTime));
        }
        //服务线程,任务由该线程获取和执行
        new Thread(new Runnable(){
            @Override
            public void run() {
                while (true) {
                    try {
                        //有序Map中,服务时间短的,置于顶部,那么自然就会优先被取出
                        Map.Entry<Integer,Task> entry = treeMap.pollFirstEntry();
                        if (entry == null){
                            Thread.currentThread().sleep(100);
                        }else {
                            entry.getValue().execute();
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }
}

3.3 结果分析

add任务有序,确实按照从前往后顺序提交的

execute任务无序,按servtime排序,说明执行时间段的得到了优先执行


3.4 优缺点

适用于任务时间差别较大的场景,仍然以进站为例,拿出公交卡的优先刷卡,还没办卡的让一让。

解决了FCFS整体处理时间长的问题,降低平均等待时间,提高了系统吞吐量。

未考虑作业的紧迫程度,因而不能保证紧迫性作业(进程)的及时处理

对长作业的不利,可能等待很久而得不到执行

时间基于预估和申报,主观性因素在内,无法做到100%的精准


4 时间片轮转(RR)

4.1 概念

时间片逐个扫描轮询,轮到谁谁执行。大家公平裁决来者有份,谁也别插队。像是棋牌游戏中的发牌操作,做到了

时间和机会上的平均性。


4.2 实现

基于数组做为数据插槽方式实现。

package com.oldlu.schedule;
import java.util.Random;
public class RR {
    //定义数组作为插槽,每个插槽中可以放入任务
    Integer[] integers;
    //length插槽的个数
    public RR(int length){
        integers = new Integer[length];
    }
    //将任务放入插槽
    public void addTask(int value){
        int slot = 0;
        //不停查找空的插槽
        while (true) {
            //发现空位,将当前任务放入
            if (integers[slot] == null){
                integers[slot] = value;
                System.out.println(String.format("‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐>add task
index=%s,value=%s",slot,value));
                break;
            }
            //如果当前位置有任务占用,看下一个位置
            slot++;
            //如果插槽遍历完还是没有空位置,那么从头开始再找,继续下一个轮回
            if (slot == integers.length){
                slot = 0;
            }
        }
    }
    //执行任务。轮询的策略就在这里
    public void execute(){
        //开启一个线程处理任务。在现实中可能有多个消费者来处理
        new Thread(new Runnable() {
            @Override
            public void run() {
                int index = 0;
                while (true) {
                    //指针轮询,如果到达尾部,下一步重新转向开头
                    // 数据物理结构是一个数组,逻辑上是一个环
                    if (index == integers.length){
                        index = 0;
                    }
                    //如果当前位置没有任务,轮询到下一个插槽
                    if (integers[index] == null){
                        index++;
                        continue;
                    }else{
                        //随机等待,表示模拟当前任务有一个执行时间
try {
                            Thread.currentThread().sleep(new Random().nextInt(1000));
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //模拟任务执行的内容,也就是打印一下当前插槽和里面的值
                        System.out.println(String.format("execute
index=%s,value=%s",index,integers[index]));
                        //执行完,将当前插槽清空,腾出位置来给后续任务使用
                        integers[index] = null;
                    }
                }
            }
        }).start();
    }
    public static void main(String[] args) {
        //测试开始,定义3个插槽
        RR rr = new RR(3);
        //唤起执行者线程,开始轮询
        rr.execute();
        //放置10个任务
        for (int i = 0; i < 10; i++) {
            rr.addTask(i);
        }
    }
}

4.3 结果分析

add任务index无序,value有序,说明是按顺序提交的,但是插槽无序,哪里有空放哪里

execute执行index有序value无序,说明任务是轮询执行的,每个插槽里的任务不一定是谁

4.4 优缺点

做到了机会的相对平均,不会因为某个任务执行时间超长而永远得不到执行

缺乏任务主次的处理。重要的任务无法得到优先执行,必须等到时间片轮到自己,着急也没用

5 优先级调度(HPF)

5.1 概述

进程调度每次将处理机分配给具有最高优先级的就绪进程。最高优先级算法可与不同的CPU方式结合形成可抢占式

最高优先级算法和不可抢占式最高优先级算法。

5.2 实现

在Task类中新增一个属性level作为优先级标识

package com.oldlu.schedule;
/**
 * 任务类
 */
public class Task {
    //任务名称
    private String name;
    //任务提交的时间
    private Long addTime;
    //任务的执行时间
    private int servTime;
    //任务优先级
    private int level;
    public Task(String name, int servTime) {
        this.name = name;
        this.servTime = servTime;
        this.addTime = System.currentTimeMillis();
    }
    public Task(String name, int servTime,int level) {
        this.name = name;
        this.servTime = servTime;
        this.level = level;
        this.addTime = System.currentTimeMillis();
    }
    public void execute() {
        try {
            // !重点:执行时睡眠,表示该任务耗时servTime毫秒
            Thread.currentThread().sleep(servTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(
                String.format("execute:name=%s,level=%s,addTime=%s,servTime=%s",
                name,level, addTime, servTime));
    }
}

依然使用TreeMap实现排序,注意的是,key要取优先级

package com.oldlu.schedule;
import java.util.Map;
import java.util.Random;
import java.util.TreeMap;
public class HPF {
    public static void main(String[] args) throws InterruptedException {
        //有序Map,将服务优先级作为key排序
        final TreeMap<Integer, Task> treeMap = new TreeMap();
        //向队列中放入5个任务
        for (int i = 0; i < 5; i++) {
            System.out.println("add task:" + i);
            int servTime = new Random().nextInt(1000);
            //注意放入的key,是优先级,这里用i标识
            treeMap.put(i, new Task("task" + i, servTime,i));
        }
        //服务线程,任务由该线程获取和执行
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        //有序Map中,优先级最高的,在底部部,那么自然就会优先被取出
                        Map.Entry<Integer, Task> entry = treeMap.pollLastEntry();
                        if (entry == null) {
                            Thread.currentThread().sleep(100);
                        } else {
                            entry.getValue().execute();
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }
}

按0-4顺序加入task

执行时,按4-0,优先级高的先得到执行,而与服务时间,加入的时间无关

目录
相关文章
|
10天前
|
JSON Java Apache
非常实用的Http应用框架,杜绝Java Http 接口对接繁琐编程
UniHttp 是一个声明式的 HTTP 接口对接框架,帮助开发者快速对接第三方 HTTP 接口。通过 @HttpApi 注解定义接口,使用 @GetHttpInterface 和 @PostHttpInterface 等注解配置请求方法和参数。支持自定义代理逻辑、全局请求参数、错误处理和连接池配置,提高代码的内聚性和可读性。
|
12天前
|
安全 Java 测试技术
Java并行流陷阱:为什么指定线程池可能是个坏主意
本文探讨了Java并行流的使用陷阱,尤其是指定线程池的问题。文章分析了并行流的设计思想,指出了指定线程池的弊端,并提供了使用CompletableFuture等替代方案。同时,介绍了Parallel Collector库在处理阻塞任务时的优势和特点。
|
8天前
|
安全 Java 开发者
深入解读JAVA多线程:wait()、notify()、notifyAll()的奥秘
在Java多线程编程中,`wait()`、`notify()`和`notifyAll()`方法是实现线程间通信和同步的关键机制。这些方法定义在`java.lang.Object`类中,每个Java对象都可以作为线程间通信的媒介。本文将详细解析这三个方法的使用方法和最佳实践,帮助开发者更高效地进行多线程编程。 示例代码展示了如何在同步方法中使用这些方法,确保线程安全和高效的通信。
28 9
|
14天前
|
算法 调度
基于遗传模拟退火混合优化算法的车间作业最优调度matlab仿真,输出甘特图
车间作业调度问题(JSSP)通过遗传算法(GA)和模拟退火算法(SA)优化多个作业在并行工作中心上的加工顺序和时间,以最小化总完成时间和机器闲置时间。MATLAB2022a版本运行测试,展示了有效性和可行性。核心程序采用作业列表表示法,结合遗传操作和模拟退火过程,提高算法性能。
|
11天前
|
存储 安全 Java
Java多线程编程的艺术:从基础到实践####
本文深入探讨了Java多线程编程的核心概念、应用场景及其实现方式,旨在帮助开发者理解并掌握多线程编程的基本技能。文章首先概述了多线程的重要性和常见挑战,随后详细介绍了Java中创建和管理线程的两种主要方式:继承Thread类与实现Runnable接口。通过实例代码,本文展示了如何正确启动、运行及同步线程,以及如何处理线程间的通信与协作问题。最后,文章总结了多线程编程的最佳实践,为读者在实际项目中应用多线程技术提供了宝贵的参考。 ####
|
8天前
|
监控 安全 Java
Java中的多线程编程:从入门到实践####
本文将深入浅出地探讨Java多线程编程的核心概念、应用场景及实践技巧。不同于传统的摘要形式,本文将以一个简短的代码示例作为开篇,直接展示多线程的魅力,随后再详细解析其背后的原理与实现方式,旨在帮助读者快速理解并掌握Java多线程编程的基本技能。 ```java // 简单的多线程示例:创建两个线程,分别打印不同的消息 public class SimpleMultithreading { public static void main(String[] args) { Thread thread1 = new Thread(() -> System.out.prin
|
11天前
|
Java
JAVA多线程通信:为何wait()与notify()如此重要?
在Java多线程编程中,`wait()` 和 `notify()/notifyAll()` 方法是实现线程间通信的核心机制。它们通过基于锁的方式,使线程在条件不满足时进入休眠状态,并在条件满足时被唤醒,从而确保数据一致性和同步。相比其他通信方式,如忙等待,这些方法更高效灵活。 示例代码展示了如何在生产者-消费者模型中使用这些方法实现线程间的协调和同步。
26 3
|
10天前
|
安全 Java
Java多线程集合类
本文介绍了Java中线程安全的问题及解决方案。通过示例代码展示了使用`CopyOnWriteArrayList`、`CopyOnWriteArraySet`和`ConcurrentHashMap`来解决多线程环境下集合操作的线程安全问题。这些类通过不同的机制确保了线程安全,提高了并发性能。
|
12天前
|
SQL Java 数据库连接
从理论到实践:Hibernate与JPA在Java项目中的实际应用
本文介绍了Java持久层框架Hibernate和JPA的基本概念及其在具体项目中的应用。通过一个在线书店系统的实例,展示了如何使用@Entity注解定义实体类、通过Spring Data JPA定义仓库接口、在服务层调用方法进行数据库操作,以及使用JPQL编写自定义查询和管理事务。这些技术不仅简化了数据库操作,还显著提升了开发效率。
26 3
|
11天前
|
Java
java小知识—进程和线程
进程 进程是程序的一次执行过程,是系统运行的基本单位,因此进程是动态的。系统运行一个程序即是一个进程从创建,运行到消亡的过程。简单来说,一个进程就是一个执行中的程序,它在计算机中一个指令接着一个指令地执行着,同时,每个进程还占有某些系统资源如CPU时间,内存空间,文件,文件,输入输出设备的使用权等等。换句话说,当程序在执行时,将会被操作系统载入内存中。 线程 线程,与进程相似,但线程是一个比进程更小的执行单位。一个进程在其执行的过程中产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源,所以系统在产生一个线程,或是在各个线程之间做切换工作时,负担要比
22 1