記事ディレクトリ
1. タイミングアルゴリズムの概要
システムやプロジェクトでは、自動実行が必要なさまざまなタスクが必然的に発生します。これらのタスクを実現するには、オペレーティングシステムの crontab、Spring Framework の Quartz、Java の Timer や ScheduledThreadPool など、さまざまな手段があります。スケジュールされたタスクの典型的な手段です。
2、最小ヒープアルゴリズム
1。概要
优先级队列+最小堆タイマーは、Java で最も典型的な実装ベースのタイマーです。タイミング タスクを内部的に保存するための優先キューを維持します。優先キューは最小限のヒープ ソートを使用します。
スケジュール メソッドを呼び出すと、新しいタスクがキューに追加され、ヒープが再配置され、ヒープの先頭が常に最小の実行時間に保たれます (つまり、すぐに実行されます)。同時に、内部スレッドはキューを継続的にスキャンすることに相当し、ヒープの先頭要素がキューから順番に取得されて実行され、タスクがスケジュールされます。
2. Javaは最小ヒープアルゴリズムを実現します
以下では、タイマーを例として、優先キュー + 最小ヒープ アルゴリズムの実装原理を紹介します。
(1) タイマーの使用
// 基本使用
import java.util.Timer;
import java.util.TimerTask;
class Task extends TimerTask {
@Override
public void run() {
System.out.println("running...");
}
}
public class TimerDemo {
public static void main(String[] args) {
Timer t=new Timer();
//在1秒后执行,以后每2秒跑一次
t.schedule(new Task(), 1000,2000);
}
}
(2) ソースコード解析
t.schedule は最終的に TaskQueue の add メソッドを呼び出します。新しいタスクが追加されると、t.schedule メソッドはキューに追加します。
// java.util.Timer#schedule(java.util.TimerTask, long, long)
public void schedule(TimerTask task, long delay, long period) {
if (delay < 0)
throw new IllegalArgumentException("Negative delay.");
if (period <= 0)
throw new IllegalArgumentException("Non-positive period.");
sched(task, System.currentTimeMillis()+delay, -period);
}
// java.util.Timer#sched
private void sched(TimerTask task, long time, long period) {
if (time < 0)
throw new IllegalArgumentException("Illegal execution time.");
// Constrain value of period sufficiently to prevent numeric
// overflow while still being effectively infinitely large.
if (Math.abs(period) > (Long.MAX_VALUE >> 1))
period >>= 1;
synchronized(queue) {
if (!thread.newTasksMayBeScheduled)
throw new IllegalStateException("Timer already cancelled.");
synchronized(task.lock) {
if (task.state != TimerTask.VIRGIN)
throw new IllegalStateException(
"Task already scheduled or cancelled");
task.nextExecutionTime = time;
task.period = period;
task.state = TimerTask.SCHEDULED;
}
queue.add(task);
if (queue.getMin() == task)
queue.notify();
}
}
// java.util.TaskQueue#add
void add(TimerTask task) {
// Grow backing store if necessary
if (size + 1 == queue.length)
queue = Arrays.copyOf(queue, 2*queue.length);
queue[++size] = task;
fixUp(size);
}
add は、容量のメンテナンスを実装し、不足している場合は容量を拡張し、同時に新しいタスクをキューの末尾に追加し、ヒープのソートをトリガーし、常にヒープの最上位要素を最小に保ちます。
// java.util.TaskQueue#fixUp
//最小堆排序
private void fixUp(int k) {
while (k > 1) {
//k指针指向当前新加入的节点，也就是队列的末尾节点，j为其父节点
int j = k >> 1;
//如果新加入的执行时间比父节点晚，那不需要动
if (queue[j].nextExecutionTime <= queue[k].nextExecutionTime)
break;
//如果大于其父节点，父子交换
TimerTask tmp = queue[j]; queue[j] = queue[k]; queue[k] = tmp;
//交换后，当前指针继续指向新加入的节点，继续循环，知道堆重排合格
k = j;
}
}
スレッドスケジューリングでの実行は主に内部の mainLoop() メソッドを呼び出し、while ループを使用します。
// java.util.TimerThread#mainLoop
private void mainLoop() {
while (true) {
try {
TimerTask task;
boolean taskFired;
synchronized(queue) {
// Wait for queue to become non-empty
while (queue.isEmpty() && newTasksMayBeScheduled)
queue.wait();
if (queue.isEmpty())
break; // Queue is empty and will forever remain; die
// Queue nonempty; look at first evt and do the right thing
long currentTime, executionTime;
task = queue.getMin();
synchronized(task.lock) {
if (task.state == TimerTask.CANCELLED) {
queue.removeMin();
continue; // No action required, poll queue again
}
// 当前时间
currentTime = System.currentTimeMillis();
//要执行的时间
executionTime = task.nextExecutionTime;
//判断是否到了执行时间
if (taskFired = (executionTime<=currentTime)) {
//判断下一次执行时间，单次的执行完移除
//循环的修改下次执行时间
if (task.period == 0) {
// Non-repeating, remove
queue.removeMin();
task.state = TimerTask.EXECUTED;
} else {
// Repeating task, reschedule
//下次时间的计算有两种策略
//1.period是负数,那下一次的执行时间就是当前时间‐period
//2.period是正数,那下一次就是该任务本次的执行时间+period
//注意！这两种策略大不相同。因为Timer是单线程的
//如果是1，那么currentTime是当前时间，就受任务执行长短影响
//如果是2，那么executionTime是绝对时间戳，与任务长短无关
queue.rescheduleMin(
task.period<0 ? currentTime - task.period
: executionTime + task.period);
}
}
}
//不到执行时间，等待
if (!taskFired) // Task hasn't yet fired; wait
queue.wait(executionTime - currentTime);
}
//到达执行时间，run！
if (taskFired) // Task fired; run it, holding no locks
task.run();
} catch(InterruptedException e) {
}
}
}
3. アプリケーション
タイマーは時代遅れであり、実際のアプリケーションで推奨されていますScheduledThreadPoolExecutor(DelayedWorkQueue と最小ヒープ ソートも内部で使用されます)。
タイマーはシングルスレッドで、1 つが失敗するか例外が発生すると、すべてのタスク キューが中断され、スレッド プールは中断されません。タイマーは
jdk1.3 以降であり、スレッド プールには jdk1.5 以降が必要です。
3. タイムホイールアルゴリズム
1。概要
タイム ホイールは、より一般的なタイミング スケジューリング アルゴリズム、さまざまなオペレーティング システム、Linux crontab、Java ベースの通信フレームワーク Netty などのタイミング タスク スケジューリングです。そのインスピレーションは私たちの生活の中にあるものから来ています时钟。
ルーレットは実際には 1 つで头尾相接的环状数组、配列の数はスロットの数であり、各スロットにタスクを配置できます。
1 日を例として、取得した値に従ってタイムホイール上にタスク実行時間 %12 を配置し、ホイールに沿って時間ポインタをスキャンし、スキャンされたポイントでのタスク実行を取り出します。
質問: たとえば、3 時に実行するタスクが複数ある場合はどうすればよいですか?
回答: 各スロットにキューを設定すると、タイムポイントの競合の問題を解決するためにキューを無限に追加できます (HashMap 構造と同様)
質問: ルーレットの時間は限られているのですが、例えば1ヶ月後の3日目の5時に何をすればいいでしょうか？
オプション 1: 期間を 1 年に延長します。
長所と短所: シンプル、多くのメモリを消費する、スロットにタスクがない場合でも空のポーリング、リソースの無駄、時間と空間の複雑さ。
解決策 2: 各タスクは、実行回数を示すカウンターを記録します。ポインタが追いつかない場合はカウンタを1減算し、0になると再度実行します。
長所と短所: ポインタに到達するたびに、判断をたどるためにリンクされたリストを取り出す必要があり、時間の計算量は高くなりますが、空間の計算量は低くなります。
解決策 3: 複数のタイムホイール、年輪、月輪、およびスカイホイールを設定します。1日以内に天輪に入れ、1年後に年輪に入れ、現在の年輪の指針を読み取ったら、タスクを取り出し、次の月輪に対応するスロットに入れます。レベルを上げ、最小精度が得られるまで月ホイールから天ホイールに移動し、タスクが実行されます。
長所と短所: 追加の移動時間は必要ありませんが、複数ラウンド分のスペースが必要になります。空間の複雑さは増加しますが、時間の複雑さは減少します。
2. Java はタイム ホイール アルゴリズムを実装します
public class RoundTask {
//延迟多少秒后执行
int delay;
//加入的序列号，只是标记一下加入的顺序
int index;
public RoundTask(int index, int delay) {
this.index = index;
this.delay = delay;
}
void run() {
System.out.println("task " + index + " start , delay = "+delay);
}
@Override
public String toString() {
return String.valueOf(delay);
}
}
import java.util.LinkedList;
import java.util.Random;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
public class RoundDemo {
//小轮槽数
int size1=10;
//大轮槽数
int size2=5;
//小轮，数组，每个元素是一个链表
LinkedList<RoundTask>[] t1 = new LinkedList[size1];
//大轮
LinkedList<RoundTask>[] t2 = new LinkedList[size2];
//小轮计数器，指针跳动的格数，每秒加1
final AtomicInteger flag1=new AtomicInteger(0);
//大轮计数器，指针跳动个格数，即每10s加1
final AtomicInteger flag2=new AtomicInteger(0);
//调度器，拖动指针跳动
ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
public RoundDemo(){
//初始化时间轮
for (int i = 0; i < size1; i++) {
t1[i]=new LinkedList<>();
}
for (int i = 0; i < size2; i++) {
t2[i]=new LinkedList<>();
}
}
//打印时间轮的结构，数组+链表
void print(){
System.out.println("t1:");
for (int i = 0; i < t1.length; i++) {
System.out.println(t1[i]);
}
System.out.println("t2:");
for (int i = 0; i < t2.length; i++) {
System.out.println(t2[i]);
}
}
//添加任务到时间轮
void add(RoundTask task){
int delay = task.delay;
if (delay < size1){
//10以内的，在小轮，槽取余数
t1[delay%size1].addLast(task);
}else {
//超过小轮的放入大轮，槽除以小轮的长度
t2[delay/size1].addLast(task);
}
}
void startT1(){
//每秒执行一次，推动时间轮旋转，取到任务立马执行
service.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
int point = flag1.getAndIncrement()%size1;
System.out.println("t1 -----> slot "+point);
LinkedList<RoundTask> list = t1[point];
if (!list.isEmpty()){
//如果当前槽内有任务，取出来，依次执行，执行完移除
while (list.size() != 0){
list.getFirst().run();
list.removeFirst();
}
}
}
},0,1, TimeUnit.SECONDS);
}
void startT2(){
//每10秒执行一次，推动时间轮旋转，取到任务下方到t1
service.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
int point = flag2.getAndIncrement()%size2;
System.out.println("t2 =====> slot "+point);
LinkedList<RoundTask> list = t2[point];
if (!list.isEmpty()){
//如果当前槽内有任务，取出，放到定义的小轮
while (list.size() != 0){
RoundTask task = list.getFirst();
//放入小轮哪个槽呢？小轮的槽按10取余数
t1[task.delay % size1].addLast(task);
//从大轮中移除
list.removeFirst();
}
}
}
},0,10, TimeUnit.SECONDS);
}
public static void main(String[] args) {
RoundDemo roundDemo = new RoundDemo();
//生成100个任务，每个任务的延迟时间随机
for (int i = 0; i < 100; i++) {
roundDemo.add(new RoundTask(i,new Random().nextInt(50)));
}
//打印，查看时间轮任务布局
roundDemo.print();
//启动大轮
roundDemo.startT2();
//小轮启动
roundDemo.startT1();
}
}
出力結果は、インデックスがいつ送信されたかに関係なく、厳密に遅延順序で実行されます。 t1 は
小さいラウンド、10 スロット、各 1 秒、10 秒ラウンド
t2 は大きなラウンド、5 スロット、各 10 秒、50 秒ラウンド
t1 のそれぞれにループする場合スロットの場合、スロット内のタスク データ (例: t1–>slot9) を出力し、9 の実行データを 3 つ出力します。t2 が
各スロットにループするとき、スロット内のタスク遅延時間の残りを 10 で取り、それを対応する t1 スロット、 t2==>slot1 の場合
、t1 が対応するターン数回転した後、t2 からタスクをフェッチして実行できます (10、11... など)。