Java線程池架構(gòu)(二)多線程調(diào)度器
在前面介紹了java的多線程的基本原理信息：《Java線程池架構(gòu)原理和源碼解析》，本文對(duì)這個(gè)java本身的線程池的調(diào)度器做一個(gè)簡(jiǎn)單擴(kuò)展，如果還沒(méi)讀過(guò)上一篇文章，建議讀一下，因?yàn)檫@是調(diào)度器的核心組件部分。
我們?nèi)绻胘ava默認(rèn)的線程池來(lái)做調(diào)度器，一種選擇就是Timer和TimerTask的結(jié)合，在以前的文章：《Timer與 TimerTask的真正原理&使用介紹》中有明確的說(shuō)明：一個(gè)Timer為一個(gè)單獨(dú)的線程，雖然一個(gè)Timer可以調(diào)度多個(gè) TimerTask，但是對(duì)于一個(gè)Timer來(lái)講是串行的，至于細(xì)節(jié)請(qǐng)參看對(duì)應(yīng)的那篇文章的內(nèi)容，本文介紹的多線程調(diào)度器，也就是定時(shí)任務(wù)，基于多線程調(diào) 度完成，當(dāng)然你可以為了完成多線程使用多個(gè)Timer，只是這些Timer的管理需要你來(lái)完成，不是一個(gè)框架體系，而 ScheduleThreadPoolExecutor提供了這個(gè)功能，所以我們第一要搞清楚是如何使用調(diào)度器的，其次是需要知道它的內(nèi)部原理是什么，也 就是知其然，再知其所以然！
首先如果我們要?jiǎng)?chuàng)建一個(gè)基于java本身的調(diào)度池通常的方法是：
- Executors.newScheduledThreadPool(int);
當(dāng)有重載方法，我們最常用的是這個(gè)就從這個(gè)，看下定義：
- public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
- return new ScheduledThreadPoolExecutor(corePoolSize);
- }
其實(shí)內(nèi)部是new了一個(gè)實(shí)例化對(duì)象出來(lái)，并傳入大小，此時(shí)就跟蹤到ScheduledThreadPoolExecutor的構(gòu)造方法中：
- public ScheduledThreadPoolExecutor(int corePoolSize) {
- super(corePoolSize, Integer.MAX_VALUE, 0,TimeUnit.NANOSECONDS,
- new DelayedWorkQueue());
- }
你會(huì)發(fā)現(xiàn)調(diào)用了super，而super你跟蹤進(jìn)去會(huì)發(fā)現(xiàn)，是ThreadPoolExecutor中，那么 ScheduledThreadPoolExecutor和ThreadPoolExecutor有何區(qū)別，就是本文要說(shuō)得重點(diǎn)了，首先我們留下個(gè)引子， 你發(fā)現(xiàn)在定義隊(duì)列的時(shí)候，不再是上文中提到的LinkedBlockingQueue，而是DelayedWorkQueue，那么細(xì)節(jié)上我們接下來(lái)就是 要講解的重點(diǎn)，既然他們又繼承關(guān)系，其實(shí)搞懂了不同點(diǎn)，就搞懂了共同點(diǎn)，而且有這樣的關(guān)系大多數(shù)應(yīng)當(dāng)是共同點(diǎn)，不同點(diǎn)的猜測(cè)：這個(gè)是要實(shí)現(xiàn)任務(wù)調(diào)度，任務(wù) 調(diào)度不是立即的，需要延遲和定期做等情況，那么是如何實(shí)現(xiàn)的呢？
這就是我們需要思考的了，通過(guò)源碼考察，我們發(fā)現(xiàn)，他們都有execute方法，只是ScheduledThreadPoolExecutor將源碼進(jìn)行了重寫，并且還有以下四個(gè)調(diào)度器的方法：
- public ScheduledFuture<?> schedule(Runnable command,
- long delay, TimeUnit unit);
- public ScheduledFuture schedule(Callable callable,
- long delay, TimeUnit unit);
- public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
- long initialDelay,
- long period,
- TimeUnit unit);
- public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
- long initialDelay,
- long delay,
- TimeUnit unit);
那么這四個(gè)方法有什么區(qū)別呢？其實(shí)第一個(gè)和第二個(gè)區(qū)別不大，一個(gè)是Runnable、一個(gè)是Callable，內(nèi)部包裝后是一樣的效果；所以把頭兩個(gè)方法幾乎當(dāng)成一種調(diào)度，那么三種情況分別是：
1、 進(jìn)行一次延遲調(diào)度：延遲delay這么長(zhǎng)時(shí)間，單位為：TimeUnit傳入的的一個(gè)基本單位，例如：TimeUnit.SECONDS屬于提供好的枚舉信息；（適合于方法1和方法2）。
2、 多次調(diào)度，每次依照上一次預(yù)計(jì)調(diào)度時(shí)間進(jìn)行調(diào)度，例如：延遲2s開(kāi)始，5s一次，那么就是2、7、12、17，如果中間由于某種原因?qū)е戮€程不夠用，沒(méi)有 得到調(diào)度機(jī)會(huì)，那么接下來(lái)計(jì)算的時(shí)間會(huì)優(yōu)先計(jì)算進(jìn)去，因?yàn)樗呐判驎?huì)被排在前面，有點(diǎn)類似Timer中的：scheduleAtFixedRate方法， 只是這里是多線程的，它的方法名也叫：scheduleAtFixedRate，所以這個(gè)是比較好記憶的（適合方法3）
3、 多次調(diào)度，每次按照上一次實(shí)際執(zhí)行的時(shí)間進(jìn)行計(jì)算下一次時(shí)間，同上，如果在第7秒沒(méi)有被得到調(diào)度，而是第9s才得到調(diào)度，那么計(jì)算下一次調(diào)度時(shí)間就不是12秒，而是9+5=14s，如果再次延遲，就會(huì)延遲一個(gè)周期以上，也就會(huì)出現(xiàn)少調(diào)用的情況（適合于方法3）；
4、 最后補(bǔ)充execute方法是一次調(diào)度，期望被立即調(diào)度，時(shí)間為空：
- public void execute(Runnable command) {
- if (command == null)
- throw new NullPointerException();
- schedule(command, 0, TimeUnit.NANOSECONDS);
- }
我們簡(jiǎn)單看看scheduleAtFixedRate、scheduleWithFixedDelay對(duì)下面的分析會(huì)更加有用途：
- public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
- long initialDelay,
- long period,
- TimeUnit unit) {
- if (command == null || unit == null)
- throw new NullPointerException();
- if (period <= 0)
- throw new IllegalArgumentException();
- RunnableScheduledFuture<?> t = decorateTask(command,
- new ScheduledFutureTask</pre>
- 兩段源碼唯一的區(qū)別就是在unit.toNanos(int)這唯一一個(gè)地方，scheduleAtFixedRate里面是直接傳入值，
- 而scheduleWithFixedDelay里面是取了相反數(shù)，也就是假如我們都傳入正數(shù)，scheduleWithFixedDelay其實(shí)就取反了，
- 沒(méi)有任何區(qū)別，你是否聯(lián)想到前面文章介紹Timer中類似的處理手段通過(guò)正負(fù)數(shù)區(qū)分時(shí)間間隔方法，為0代表僅僅調(diào)度一次，
- 其實(shí)在這里同樣是這樣的，他們也同樣有一個(gè)問(wèn)題就是，如果你傳遞負(fù)數(shù)，方法的功能正好是相反的。
- 而你會(huì)發(fā)現(xiàn)，不論是那個(gè)schedule方法里頭，都會(huì)創(chuàng)建一個(gè)ScheduledFutureTask類的實(shí)例，此類究竟是何方神圣呢，我們來(lái)看看。
- ScheduledFutureTask的類（ScheduleThreadPoolExecutor的私有的內(nèi)部類）來(lái)進(jìn)行調(diào)度，那么可以看看內(nèi)部做了什么操作，如下：
- 1
- ScheduledFutureTask(Runnable r, V result, long ns) {
- super(r, result);
- this.time = ns;
- this.period = 0;
- this.sequenceNumber = sequencer.getAndIncrement();
- }
- /**
- * Creates a periodic action with given nano time and period.
- */
- ScheduledFutureTask(Runnable r, V result, long ns, long period) {
- super(r, result);
- this.time = ns;
- this.period = period;
- this.sequenceNumber = sequencer.getAndIncrement();
- }
- /**
- * Creates a one-shot action with given nanoTime-based trigger.
- */
- ScheduledFutureTask(Callable callable, long ns) {
- super(callable);
- this.time = ns;
- this.period = 0;
- this.sequenceNumber = sequencer.getAndIncrement();
- }
最核心的幾個(gè)參數(shù)正好對(duì)應(yīng)了調(diào)度的延遲的構(gòu)造方法，這些參數(shù)如何用起來(lái)的？那么它還提供了什么方法呢？
- public long getDelay(TimeUnit unit) {
- return unit.convert(time - now(), TimeUnit.NANOSECONDS);
- }
- public int compareTo(Delayed other) {
- if (other == this) // compare zero ONLY if same object
- return 0;
- if (other instanceof ScheduledFutureTask) {
- ScheduledFutureTask<?> x = (ScheduledFutureTask<?>)other;
- long diff = time - x.time;
- if (diff < 0) return -1; else if (diff > 0)
- return 1;
- else if (sequenceNumber < x.sequenceNumber)
- return -1;
- else
- return 1;
- }
- long d = (getDelay(TimeUnit.NANOSECONDS) -
- other.getDelay(TimeUnit.NANOSECONDS));
- return (d == 0)? 0 : ((d < 0)? -1 : 1); }
- /** * 返回是否為片段，也就是多次調(diào)度 * */
- public boolean isPeriodic() { return period != 0; }
這里發(fā)現(xiàn)了，他們可以運(yùn)行，且判定時(shí)間的方法是getDelay方法我們知道了。 對(duì)比時(shí)間的方法是：compareTo，傳入了參數(shù)類型為：Delayed類型，不難猜測(cè)出，ScheduledFutureTask和Delayed有 某種繼承關(guān)系，沒(méi)錯(cuò)，ScheduledFutureTask實(shí)現(xiàn)了Delayed的接口，只是它是間接實(shí)現(xiàn)的；并且Delayed接口繼承了 Comparable接口，這個(gè)接口可用來(lái)干什么？看過(guò)我前面寫的一篇文章關(guān)于中文和對(duì)象排序的應(yīng)該知道，這個(gè)是用來(lái)自定義對(duì)比和排序的，我們的調(diào)度任務(wù) 是一個(gè)對(duì)象，所以需要排序才行，接下來(lái)我們回溯到開(kāi)始定義的代碼中，找一個(gè)實(shí)際調(diào)用的代碼來(lái)看看它是如何啟動(dòng)到run方法的？如何排序的？如何調(diào)用延遲 的？就是我們下文中會(huì)提到的，而這里我們先提出問(wèn)題，后文我們?cè)賮?lái)說(shuō)明這些問(wèn)題。 我們先來(lái)看下run方法的一些定義。
- /** * 時(shí)間片類型任務(wù)執(zhí)行 */
- private void runPeriodic() {
- //運(yùn)行對(duì)應(yīng)的程序，這個(gè)是具體的程序 boolean ok = ScheduledFutureTask.super.runAndReset();
- boolean down = isShutdown(); // Reschedule if not cancelled and not shutdown or policy allows
- if (ok && (!down ||(getContinueExistingPeriodicTasksAfterShutdownPolicy() &&!isStopped()))) {
- long p = period;
- if (p > 0)//規(guī)定時(shí)間間隔算出下一次時(shí)間
- time += p;
- else//用當(dāng)前時(shí)間算出下一次時(shí)間，負(fù)負(fù)得正
- time = triggerTime(-p);
- //計(jì)算下一次時(shí)間，并資深再次放入等待隊(duì)列中
- ScheduledThreadPoolExecutor.super.getQueue().add(this);
- }
- else if (down)
- interruptIdleWorkers();
- }
- /**
- * 是否為逐片段執(zhí)行，如果不是，則調(diào)用父親類的run方法
- */
- public void run() {
- if (isPeriodic())//周期任務(wù)
- runPeriodic();
- else//只執(zhí)行一次的任務(wù)
- ScheduledFutureTask.super.run();
- }
可以看到run方法首先通過(guò)isPeriod()判定是否為時(shí)間片，判定的依據(jù)就是我們說(shuō)的時(shí)間片是否“不為零”，如果不是周期任務(wù)，就直接運(yùn)行一 次，如果是周期任務(wù)，則除了運(yùn)行還會(huì)計(jì)算下一次執(zhí)行的時(shí)間，并將其再次放入等待隊(duì)列，這里對(duì)應(yīng)到scheduleAtFixedRate、 scheduleWithFixedDelay這兩個(gè)方法一正一負(fù)，在這里得到判定，并且將為負(fù)數(shù)的取反回來(lái)，負(fù)負(fù)得正，java就是這么干的，呵呵，所 以不要認(rèn)為什么是不可能的，只要好用什么都是可以的，然后計(jì)算的時(shí)間一個(gè)是基于標(biāo)準(zhǔn)的time加上一個(gè)時(shí)間片，一個(gè)是根據(jù)當(dāng)前時(shí)間計(jì)算一個(gè)時(shí)間片，在上文 中我們已經(jīng)明確說(shuō)明了兩者的區(qū)別。
以：schedule方法為例：
- public ScheduledFuture schedule(Callable callable,
- long delay,
- TimeUnit unit) {
- if (callable == null || unit == null)
- throw new NullPointerException();
- RunnableScheduledFuture t = decorateTask(callable,
- new ScheduledFutureTask(callable,
- triggerTime(delay, unit)));
- delayedExecute(t);
- return t;
- }
其實(shí)這個(gè)方法內(nèi)部創(chuàng)建的就是一個(gè)我們剛才提到的：ScheduledFutureTask，外面又包裝了下叫做RunnableScheduledFuture，也就是適配了下而已，呵呵，代碼里面就是一個(gè)return操作，java這樣做的目的是方便子類去擴(kuò)展。
關(guān)鍵是delayedExecute(t)方法中做了什么？看名稱是延遲執(zhí)行的意思，難道java的線程可以延遲執(zhí)行，那所有的任務(wù)線程都在運(yùn)行狀態(tài)？
它的源碼是這樣的：
- private void delayedExecute(Runnable command) {
- if (isShutdown()) {
- reject(command);
- return;
- }
- if (getPoolSize() < getCorePoolSize())
- prestartCoreThread();
- super.getQueue().add(command);
- }
我們主要關(guān)心prestartCoreThread()和super.getQueue().add(command)，因?yàn)槿绻到y(tǒng)關(guān)閉，這些討論都沒(méi)有意義的，我們分別叫他們第二小段代碼和第三小段代碼。
第二個(gè)部分如果線程數(shù)小于核心線程數(shù)設(shè)置，那么就調(diào)用一個(gè)prestartCoreThread()，看方法名應(yīng)該是：預(yù)先啟動(dòng)一個(gè)核心線程的意思，先看完第三個(gè)部分，再跟蹤進(jìn)去看源碼。
第三個(gè)部分很明了，就是調(diào)用super.getQueue().add(command);也就是說(shuō)直接將任務(wù)放入一個(gè)隊(duì)列中，其實(shí)super是什 么？super就是我們上一篇文章所提到的ThreadPoolExecutor，那么這個(gè)Queue就是上一篇文章中提到的等待隊(duì)列，也就是任何 schedule任務(wù)首先放入等待隊(duì)列，然后等待被調(diào)度的。
- public boolean prestartCoreThread() {
- return addIfUnderCorePoolSize(null);
- }
- private boolean addIfUnderCorePoolSize(Runnable firstTask) {
- Thread t = null;
- final ReentrantLock mainLock = this.mainLock;
- mainLock.lock();
- try {
- if (poolSize < corePoolSize && runState == RUNNING)
- t = addThread(firstTask);
- } finally {
- mainLock.unlock();
- } if (t == null)
- return false;
- t.start();
- return true;
- }
這個(gè)代碼是否似曾相似，沒(méi)錯(cuò)，這個(gè)你在上一篇文章介紹ThreadPoolExecutor的時(shí)候就見(jiàn)到過(guò)，說(shuō)明不論是 ThreadPoolExecutor還是ScheduleThreadPoolExecutor他們的Thread都是由一個(gè)Worker來(lái)處理的（上 一篇文章有介紹），而這個(gè)Worker處理的基本機(jī)制就是將當(dāng)前任務(wù)執(zhí)行后，不斷從線程等待隊(duì)列中獲取數(shù)據(jù)，然后用以執(zhí)行，直到隊(duì)列為空為止。 那么他們的區(qū)別在哪里呢？延遲是如何實(shí)現(xiàn)的呢？和我們上面介紹的ScheduledFutureTask又有何關(guān)系呢？ 那么我們回過(guò)頭來(lái)看看ScheduleThreadPool的定義是如何的。
- public ScheduledThreadPoolExecutor(int corePoolSize) {
- super(corePoolSize, Integer.MAX_VALUE, 0,TimeUnit.NANOSECONDS, new DelayedWorkQueue()); }
發(fā)現(xiàn)它和ThreadPoolExecutor有個(gè)定義上很大的區(qū)別就是，ThreadPoolExecutor用的是 LinkedBlockingQueue（當(dāng)然可以修改），它用的是DelayedWeorkQueue，而這個(gè)DelayedWorkQueue里面你 會(huì)發(fā)現(xiàn)它僅僅是對(duì)java.util.concurrent.DelayedQueue類一個(gè)簡(jiǎn)單訪問(wèn)包裝，這個(gè)隊(duì)列就是等待隊(duì)列，可以看到任務(wù)是被直接 放到等待隊(duì)列中的，所以取數(shù)據(jù)必然從這里獲取，而這個(gè)延遲的隊(duì)列有何神奇之處呢，它又是如何實(shí)現(xiàn)的呢，我們從什么地方下手去看這個(gè) DelayWorkQueue？ 我們還是回頭看看Worker里面的run方法（上一篇文章中已經(jīng)講過(guò)）：
- public void run() {
- try {
- Runnable task = firstTask;
- firstTask = null;
- while (task != null || (task = getTask()) != null) {
- runTask(task);
- task = null;
- }
- } finally {
- workerDone(this);
- }
- }
這里面要調(diào)用等待隊(duì)列就是getTask()方法：
- Runnable getTask() {
- for (;;) {
- try { int state = runState;
- if (state > SHUTDOWN)
- return null;
- Runnable r;
- if (state == SHUTDOWN) // Help drain queue
- r = workQueue.poll();
- else if (poolSize > corePoolSize || allowCoreThreadTimeOut)
- r = workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS);
- else
- r = workQueue.take();
- if (r != null)
- return r;
- if (workerCanExit()) {
- if (runState >= SHUTDOWN) // Wake up others
- interruptIdleWorkers();
- return null;
- }
- } catch (InterruptedException ie) {
- }
- }
發(fā)現(xiàn)沒(méi)有，如果沒(méi)有設(shè)置超時(shí)，默認(rèn)只會(huì)通過(guò)workQueue.take()方法獲取數(shù)據(jù)，那么我們就看take方法，而增加到隊(duì)列里面的方法自然看offer相關(guān)的方法。接下來(lái)我們來(lái)看下DelayQueue這個(gè)隊(duì)列的take方法：
- public E take() throws InterruptedException {
- final ReentrantLock lock = this.lock;
- lock.lockInterruptibly();
- try {
- for (;;) {
- E first = q.peek();
- if (first == null) {
- available.await();//等待信號(hào)，線程一直掛在哪里
- } else {
- long delay = first.getDelay(TimeUnit.NANOSECONDS);
- if (delay > 0) {
- long tl = available.awaitNanos(delay);//最左等delay的時(shí)間段
- } else {
- E x = q.poll();//可以運(yùn)行，取出一個(gè)
- assert x != null;
- if (q.size() != 0)
- available.signalAll();
- return x;
- }
- }
- }
- } finally {
- lock.unlock();
- }
- }
這里的for就是要找到數(shù)據(jù)為止，否則就等著，而這個(gè)“q”和“available”是什么呢？
- private transient final Condition available = lock.newCondition();
- private final PriorityQueue q = new PriorityQueue();
怎么里面還有一層隊(duì)列，不用怕，從這里你貌似看出點(diǎn)名稱意味了，就是它是優(yōu)先級(jí)隊(duì)列，而對(duì)于任務(wù)調(diào)度來(lái)講，優(yōu)先級(jí)的方式就是時(shí)間，我們用這中猜測(cè)來(lái)繼續(xù)深入源碼。
上面首先獲取這個(gè)隊(duì)列的第一個(gè)元素，若為空，就等待一個(gè)“available”發(fā)出的信號(hào)，我們可以猜測(cè)到這個(gè)offer的時(shí)候會(huì)發(fā)出的信號(hào)，一會(huì) 來(lái)驗(yàn)證即可；若不為空，則通過(guò)getDelay方法來(lái)獲取時(shí)間信息，這個(gè)getDelay方法就用上了我們開(kāi)始說(shuō)的 ScheduledFutureTask了，如果是時(shí)間大于0，則也進(jìn)入等待，因?yàn)檫€沒(méi)開(kāi)始執(zhí)行，等待也是“available”發(fā)出信號(hào)，但是有一個(gè)最 長(zhǎng)時(shí)間，為什么還要等這個(gè)信號(hào)，是因?yàn)橛锌赡苓M(jìn)來(lái)一個(gè)新的任務(wù)，比這個(gè)等待的任務(wù)還要先執(zhí)行，所以要等這個(gè)信號(hào)；而最多等這么長(zhǎng)時(shí)間，就是因?yàn)槿绻@段時(shí) 間沒(méi)任務(wù)進(jìn)來(lái)肯定就是它執(zhí)行了。然后就返回的這個(gè)值，被Worker（上面有提到）拿到后調(diào)用其run()方法進(jìn)行運(yùn)行。
那么寫入隊(duì)列在那里？他們是如何排序的？
我們看看隊(duì)列的寫入方法是這樣的：
- public boolean offer(E e) {
- final ReentrantLock lock = this.lock;
- lock.lock();
- try {
- E first = q.peek();
- q.offer(e);
- if (first == null || e.compareTo(first) < 0)
- available.signalAll();
- return true;
- } finally { lock.unlock(); }
- }
隊(duì)列也是首先取出第一個(gè)（后面會(huì)用來(lái)和當(dāng)前任務(wù)做比較），而這里“q”是上面提到的“PriorityQueue”，看來(lái)offer的關(guān)鍵還在它的里面，我們看看調(diào)用過(guò)程：
- public boolean offer(E e) { if (e == null) throw new NullPointerException(); modCount++; int i = size; if (i >= queue.length)
- grow(i + 1);
- size = i + 1;
- if (i == 0)
- queue[0] = e;
- else
- siftUp(i, e);//主要是這條代碼很關(guān)鍵
- return true;
- }
- private void siftUp(int k, E x) {
- if (comparator != null)
- siftUpUsingComparator(k, x);
- else
- //我們默認(rèn)走這里，因?yàn)镈elayQueue定義它的時(shí)候默認(rèn)沒(méi)有給定義comparator
- siftUpComparable(k, x);
- }
- /*
- 可以發(fā)現(xiàn)這個(gè)方法是將任務(wù)按照compareTo對(duì)比后，放在隊(duì)列的合適位置，但是它肯定不是絕對(duì)順序的，這一點(diǎn)和Timer的內(nèi)部排序機(jī)制類似。
- */
- private void siftUpComparable(int k, E x) {
- Comparable<? super E> key = (Comparable<? super E>) x;
- while (k > 0) {
- int parent = (k - 1) >>> 1;
- Object e = queue[parent];
- if (key.compareTo((E) e) >= 0)
- break;
- queue[k] = e;
- k = parent;
- }
- queue[k] = key;
- }
你是否發(fā)現(xiàn)，compareTo也用上了，就是我們前面描述一大堆的：ScheduledFutureTask類中的一個(gè)方法，那么run方法也用上了，這個(gè)過(guò)程貌似完整了。
我們?cè)賮?lái)理一下思路：
1、調(diào)用的Thread的包裝，由在ThreadPoolExecutor中的Worker調(diào)用你傳入的Runnable的run方法，變成了Worker調(diào)用Runnable的run方法，由它來(lái)處理時(shí)間片的信息調(diào)用你傳入的線程。
2、ScheduledFutureTask類在整個(gè)過(guò)程中提供了基礎(chǔ)參考的方法，其中最為關(guān)鍵的就是實(shí)現(xiàn)了接口Comparable，實(shí)現(xiàn)內(nèi)部的 compareTo方法，也實(shí)現(xiàn)了Delayed接口中的getDelay方法用以判定時(shí)間（當(dāng)然Delayed接口本身也是繼承于 Comparable，我們不要糾結(jié)于細(xì)節(jié)概念就好）。
3、等待隊(duì)列由在ThreadPoolExecutor中默認(rèn)使用的LinkedBlockingQueue換成了DelayQueue（它是被 DelayWorkQueue包裝了一下子，沒(méi)多大區(qū)別），而DelayQueue主要提供了一個(gè)信號(hào)量“available”來(lái)作為寫入和讀取的信號(hào)控 制開(kāi)關(guān)，通過(guò)另一個(gè)優(yōu)先級(jí)隊(duì)列“PriorityQueue”來(lái)控制實(shí)際的隊(duì)列順序，他們的順序就是基于上面提到的 ScheduledFutureTask類中的compareTo方法，而是否運(yùn)行也是基于getDelay方法來(lái)實(shí)現(xiàn)的。
4、ScheduledFutureTask類的run方法會(huì)判定是否為時(shí)間片信息，如果為時(shí)間片，在執(zhí)行完對(duì)應(yīng)的方法后，開(kāi)始計(jì)算下一次執(zhí)行時(shí)間 （注意判定時(shí)間片大于0，小于0，分別代表的是以當(dāng)前執(zhí)行完的時(shí)間為準(zhǔn)計(jì)算下一次時(shí)間還是以當(dāng)前時(shí)間為準(zhǔn)），這個(gè)在前面有提到。
5、它是支持多線程的，和Timer的機(jī)制最大的區(qū)別就在于多個(gè)線程會(huì)最征用這個(gè)隊(duì)列，隊(duì)里的排序方式和Timer有很多相似之處，并非完全有序，而是通過(guò)位移動(dòng)來(lái)盡量找到合適的位置，有點(diǎn)類似貪心的算法，呵呵。
