Java线程常用调度算法与应用
Posted 赵广陆
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java线程常用调度算法与应用相关的知识,希望对你有一定的参考价值。
目录
1 调度算法应用
调度算法常见于操作系统中,因为系统资源有限,当有多个进程(或多个进程发出的请求)要使用这些资源时,就必须按照一定的原则选择进程(请求)来占用资源。这就是所谓的调度。在现实生活中也是一样,比如会议室的占用。
CPU资源调度
云计算资源调度
容器化Docker编排与调度
2 先来先服务(FCFS)
2.1 概念
先来先服务,很好理解,就是按照服务提交申请的顺序,依次执行。讲究先来后到。
2.2 实现
定义一个Task类作为任务实例,BlockingQueue作为服务队列
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,优先级高的先得到执行,而与服务时间,加入的时间无关
以上是关于Java线程常用调度算法与应用的主要内容,如果未能解决你的问题,请参考以下文章