詳解FutureTask如何實現最大等待時間

2023-03-29 06:02:32

預備知識

Java 執行緒掛起的常用方式有以下幾種

Thread.sleep(long millis)：這個方法可以讓執行緒掛起一段時間，並釋放 CPU 時間片，等待一段時間後自動恢復執行。這種方式可以用來實現簡單的定時器功能，但如果不恰當使用會影響系統效能。

Object.wait() 和 Object.notify() 或 Object.notifyAll()：這是一種通過等待某個條件的發生來掛起執行緒的方式。wait() 方法會讓執行緒等待，直到其他執行緒呼叫了 notify() 或 notifyAll() 方法來通知它。這種方式需要使用 synchronized 或者 ReentrantLock 等同步機制來保證執行緒之間的共同作業和通訊。

LockSupport.park() 和 LockSupport.unpark(Thread thread)：這兩個方法可以讓執行緒掛起和恢復。park() 方法會使當前執行緒掛起，直到其他執行緒呼叫了 unpark(Thread thread) 方法來喚醒它。這種方式比較靈活，可以根據需要控制執行緒的掛起和恢復。

先上結論

1.futureTask.get時通過LockSupport.park()掛起執行緒

2.在Thread.run() 方法中呼叫 setException(ex)或set(result)，然後呼叫LockSupport.unpark(t)喚醒執行緒。

範例-引入主題

public class FutureTaskDemo {
    public static void main(String[] args) {
        FutureTask<String> futureTask = new FutureTask<>(new Callable() {
            @Override
            public Object call() throws Exception {
                System.out.println("非同步執行緒執行");
                Thread.sleep(3000);//模擬執行緒執行任務需要3秒
                return "ok";
            }
        });
        Thread t1 = new Thread(futureTask, "執行緒一");
        t1.start();

        try {
            //關鍵程式碼
            String s = futureTask.get(2, TimeUnit.SECONDS); //最大等待執行緒2秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}

進入futureTask.get(2, TimeUnit.SECONDS)

  public V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException {
        if (unit == null)
            throw new NullPointerException();
        int s = state;
        if (s <= COMPLETING &&
            (s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING) //重點awaitDone，即完成了最大等待，依然沒有結果就丟擲異常邏輯
            throw new TimeoutException();
        return report(s);
    }

awaitDone返回執行緒任務執行狀態，即小於等於COMPLETING(任務正在執行，等待完成)丟擲異常TimeoutException

進入(awaitDone(true, unit.toNanos(timeout)))原理分析

private int awaitDone(boolean timed, long nanos)
        throws InterruptedException {
        final long deadline = timed ? System.nanoTime() + nanos : 0L;
        WaitNode q = null;
        boolean queued = false;
        for (;;) {
            if (Thread.interrupted()) {
                removeWaiter(q);
                throw new InterruptedException();
            }

            int s = state;
            if (s > COMPLETING) {
                if (q != null)
                    q.thread = null;
                return s;
            }
            else if (s == COMPLETING) // cannot time out yet
                Thread.yield();
            else if (q == null)
                q = new WaitNode();
            else if (!queued)
                queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
                                                     q.next = waiters, q);
            else if (timed) {
                nanos = deadline - System.nanoTime();
                if (nanos <= 0L) {
                    removeWaiter(q);
                    return state;
                }
                LockSupport.parkNanos(this, nanos);
            }
            else
                LockSupport.park(this);
        }
    }

總體解讀awaitDone

利用自旋(for (;