2. 程式人生 > >多執行緒高併發程式設計(7) -- Future原始碼分析

多執行緒高併發程式設計(7) -- Future原始碼分析

阿新 • • 發佈：2020-05-05

一.概念

　　A Future計算的結果。 提供方法來檢查計算是否完成，等待其完成，並檢索計算結果。 結果只能在計算完成後使用方法get進行檢索，如有必要，阻塞，直到準備就緒。 取消由cancel方法執行。 提供其他方法來確定任務是否正常完成或被取消。 計算完成後，不能取消計算。 如果您想使用Future ，以便不可撤銷，但不提供可用的結果，則可以宣告Future<?>表格的型別，並返回null作為基礎任務的結果。 

public interface Future<V> {
    //嘗試取消執行此任務。如果任務已經完成，已經被取消或由於某些其他原因而無法取消，則此嘗試將失敗。
    //如果成功，並且在呼叫 cancel 時此任務尚未開始，則該任務永遠無法執行。
    //如果任務已經開始，則 mayInterruptIfRunning 引數確定是否應中斷執行該任務的執行緒以嘗試停止該任務。
    //mayInterruptIfRunning == true， 表示中斷執行中的執行緒，false 表示讓執行緒正常完成
    boolean cancel(boolean mayInterruptIfRunning);
    //如果此任務在正常完成之前被取消，則返回true。
    boolean isCancelled();
    //如果此任務完成，則返回true。完成可能是由於正常終止，異常或取消引起的，在所有這些情況下，此方法都將返回true。
    boolean isDone();
    //必要時等待計算完成，然後檢索其結果
    V get() throws InterruptedException, ExecutionException;
    //必要時最多等待給定時間以完成計算，然後檢索其結果（如果有）。
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

　　

　　Future是一個介面，提供了方法來檢測當前的任務是否已經結束，還可以等待任務結束並且拿到一個結果，通過呼叫Future的get()方法可以當任務結束後返回一個結果值，如果工作沒有結束，則會阻塞當前執行緒，直到任務執行完畢；可以通過呼叫cancel()方法來停止一個任務，如果任務已經停止，則cancel()方法會返回true；如果任務已經完成或者已經停止了或者這個任務無法停止，則cancel()會返回一個false。當一個任務被成功停止後，他無法再次執行。isDone()和isCancel()方法可以判斷當前工作是否完成和是否取消。　　

　　類圖結構：

 

  • ScheduledFuture：這個介面表示一個延時的行為可以被取消。通常一個安排好的future是定時任務SchedualedExecutorService的結果；
  • RunnableFuture： 這個介面同時繼承Future介面和Runnable介面，在成功執行run()方法後，可以通過Future訪問執行結果；
  • ForkJoinTask：基於任務的抽象類，可以通過ForkJoinPool來執行。一個ForkJoinTask是類似於執行緒實體，但是相對於執行緒實體是輕量級的。大量的任務和子任務會被ForkJoinPool池中的真實執行緒掛起來，以某些使用限制為代價；
  • CompletableFuture：一個Future類是顯示的完成，而且能被用作一個完成等級，通過它的完成觸發支援的依賴函式和行為。當兩個或多個執行緒要執行完成或取消操作時，只有一個能夠成功；
  • RunnableScheduledFuture：執行延遲和週期性任務；在成功執行run()方法後，可以通過Future訪問執行結果；
  • FutureTask：可取消的非同步計算
    • 該類提供了一個Future的基本實現 ，具有啟動和取消計算的方法，查詢計算是否完整，並檢索計算結果。結果只能在計算完成後才能檢索; 如果計算尚未完成，則get方法將阻止。一旦計算完成，則無法重新啟動或取消計算（除非使用runAndReset()呼叫計算 ）；
    • A FutureTask可用於包裝Callable或Runnable物件。 因為FutureTask實現Runnable ，一個FutureTask可以提交到一個Executor執行；
  • RecursiveTask：遞迴結果ForkJoinTask；
  • RecursiveAction：遞迴結果ForkJoinTask；

二.用法

 　　一個場景，我們要學習做飯，那麼我們需要準備廚具和食材，廚具通過電子商務網購，食材去菜市場挑選。那麼可以使用多執行緒來併發進行，即我們可以先網購下單，在等待快遞員送貨過來的這段時間去菜市場買食材，節省時間，提高效率。

  1. 直接開啟執行緒，使用類繼承Thread重寫方法實現網購，join阻塞直到廚具到達才開始做飯。 
    public class FutureTest {
    public static void main(String[] args) throws InterruptedException {
        long startTime = System.currentTimeMillis();
        OnlineShopping shopping = new OnlineShopping();
        shopping.start();
        Thread.sleep(2000);//等待送貨執行完
        System.out.println("第二步：食材到位");
        shopping.join();//阻塞訂單直到快遞送到得到廚具
        System.out.println("第三步：開始廚藝");
        System.out.println("總共用時：" + (System.currentTimeMillis() - startTime) + "ms");
    }

    static class OnlineShopping extends Thread {
        @Override
        public void run() {
            System.out.println("第一步：下單");
            System.out.println("第一步：等待送貨");
            try {
                Thread.sleep(5000);//送貨中
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("第一步：快遞送到");
        }
    }
}
//======結果======
第一步：下單
第一步：等待送貨
第二步：食材到位
第一步：快遞送到
第三步：開始廚藝
總共用時：5003ms 
  2. 使用Future模式來完成上述操作，通過Callable返回結果來獲取廚具，可以通過FutureTask靈活地操作訂單，由此可見，比繼承Thread完成的訂單，Future模式更具有靈活性， 
    public class FutureTest {
    public static void main(String[] args) throws Exception {
        long startTime = System.currentTimeMillis();
        Callable<String> shopping = () ->{
            System.out.println("第一步：下單");
            System.out.println("第一步：等待送貨");
            Thread.sleep(5000);//快遞員送貨中
            System.out.println("第一步：快遞送到");
            return "廚具到達";
        };
        FutureTask<String> task = new FutureTask<>(shopping);
        new Thread(task).start();
        Thread.sleep(2000);//保證下單操作執行到“等待送貨”中
        System.out.println("第二步：食材到位");
        if (!task.isDone()) {  // 聯絡快遞員，詢問是否到貨
            System.out.println("第三步：廚具還沒到，心情好就等著（心情不好就呼叫cancel方法取消訂單）");
        }
        String chuju = task.get();//得到廚具
        System.out.println("第三步：開始廚藝");
        System.out.println("總共用時：" + (System.currentTimeMillis() - startTime) + "ms");
    }
}
//======結果======
第一步：下單
第一步：等待送貨
第二步：食材到位
第三步：廚具還沒到，心情好就等著（心情不好就呼叫cancel方法取消訂單）
第一步：快遞送到
第三步：開始廚藝
總共用時：5048ms 

三.分析

　　使用Future模式的三部曲：

  1. 建立Callable重寫call方法，把網購邏輯封裝到call中，返回定義結果“廚具”； 
    public interface Callable<V> {
    V call() throws Exception;
}
  2. 建立FutureTask，把Callable例項放入FutureTask的構造方法中； 
    public class FutureTask<V> implements RunnableFuture<V>{
    public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // 確保callable的可見性
    }
    public FutureTask(Runnable runnable, V result) {
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       // 確保callable的可見性
    }
}
public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

     FutureTask的run方法：Callable的call是被FutureTask的run方法呼叫的，不是非同步執行的；

    public void run() {
        // 1. 如果 state !=  NEW 說明 run 方法已經執行過，直接 return
        // 2. 如果 state == NEW && CAS 競爭 設定 runner 失敗，說明已經有別的執行緒在執行，直接 return
        // NEW 的狀態由構造方法初始化，runner 是執行該 Callable 的執行緒
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;// 這裡的callable是從構造方法裡面傳人的
            if (c != null && state == NEW) {
                V result;
                boolean ran;// 識別符號
                try {
                    result = c.call();//獲得結果
                    ran = true;
                } catch (Throwable ex) {//異常
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)//成功沒有異常，設定返回值
                    set(result);
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            //在狀態設定之前，runner必須是非空的，以防止對run()的併發呼叫
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            //為防止洩漏中斷，必須在空runner之後將狀態設定為重複讀
            int s = state;
            // 如果最終狀態 >= INTERRUPTING，則處理中斷
            // cancel 方法會通過引數 mayInterruptIfRunning 來設定 state 的值
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

     狀態屬性state：

        private volatile int state;//狀態，volatile讓狀態可見性
    private static final int NEW          = 0;//構造方法建立時的狀態
    private static final int COMPLETING   = 1;//這是一箇中間態，完成時和出現異常時有使用到
    private static final int NORMAL       = 2;//完成執行時的最終狀態
    private static final int EXCEPTIONAL  = 3;//異常時的最終狀態
    private static final int CANCELLED    = 4;//已取消
    private static final int INTERRUPTING = 5;//中斷中
    private static final int INTERRUPTED  = 6;//已中斷
    
    可能的 state 轉換：
    NEW -> COMPLETING -> NORMAL
    NEW -> COMPLETING -> EXCEPTIONAL
    NEW -> CANCELLED
    NEW -> INTERRUPTING -> INTERRUPTED

    set設定返回值：

     private Object outcome;//通過get方法獲得的返回值
    //設定返回值，狀態NEW -> COMPLETING -> NORMAL
    protected void set(V v) {
         // 這裡為什麼要用 CAS 因為可能會和 cancel 方法產生競爭。
        // 如果競爭失敗，說明取消競爭成功，在 cancel 方法承擔喚醒的工作，所以直接跳過。
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {//NEW -> COMPLETING
            // 競爭成功
            outcome = v;//outcome為返回結果
            UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // 最終狀態為NORMAL，COMPLETING -> NORMAL
            finishCompletion();
        }
    }

    setException執行時異常：

    //狀態：NEW -> COMPLETING -> EXCEPTIONAL
protected void setException(Throwable t) {
        // 這裡為什麼要用 CAS 因為可能會和 cancel 方法產生競爭。
        // 如果競爭失敗，說明取消競爭成功，在 cancel 方法承擔喚醒的工作，所以直接跳過。
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {//NEW -> COMPLETING
            // 競爭成功
            outcome = t; // outcome 為一個 Throwable
            // 把最終狀態改為 EXCEPTIONAL
            UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state，COMPLETING -> EXCEPTIONAL
            finishCompletion();
        }
    }

    finishCompletion：

        //刪除當前執行緒並喚醒所有等待執行緒，呼叫done()，並取消進行中的方法
    private void finishCompletion() {
        // assert state > COMPLETING;
        //從 waiters 末尾開始遍歷，for 自旋直到 CAS 成功。
        for (WaitNode q; (q = waiters) != null;) {
            // 使用 CAS 把 waiters 設定為 null，和 awaitDone 和 removeWatier 方法競爭
            if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
                // 自旋喚醒所有執行緒
                for (;;) {
                    Thread t = q.thread;
                    if (t != null) {
                        q.thread = null;
                        LockSupport.unpark(t);// 喚醒執行緒
                    }
                    WaitNode next = q.next;
                    if (next == null)
                        break;
                    q.next = null; // unlink to help gc
                    q = next;
                }
                break;
            }
        }
        // 這個一個空方法，主要用於繼承重寫，這也是模板模式的體現
        done();
        callable = null;        // to reduce footprint
    }
    protected void done() { }


    //===========例子==============
    //ExecutorCompletionService 的作用就是把執行緒池的執行結果放到一個已完成佇列中，方便獲取執行結果，其內部主要通過一個 FutureTask 的實現類 QueueingFuture 來實現這個功能：
    private class QueueingFuture extends FutureTask<Void> {
            QueueingFuture(RunnableFuture<V> task) {
                super(task, null);
                this.task = task;
            }
            protected void done() { completionQueue.add(task); }//done方法是FutureTask方法的重寫。FutureTask在完成時會執行done方法，把task放入已完成佇列completionQueue。
            private final Future<V> task;
        }

    get獲得返回結果：

        public V get() throws InterruptedException, ExecutionException {
        int s = state;//得到狀態
        if (s <= COMPLETING)//狀態未完成，把獲取結果的執行緒放入等待連結串列，然後阻塞，直至被中斷、完成或出現異常。
            s = awaitDone(false, 0L);
        return report(s);//返回結果
    }
    private int awaitDone(boolean timed, long nanos)
        throws InterruptedException {
        final long deadline = timed ? System.nanoTime() + nanos : 0L;//用於計時
        WaitNode q = null;
        boolean queued = false;
        for (;;) {//自旋
            //如果已經被中斷，則removeWaiter，丟擲中斷異常
            if (Thread.interrupted()) {
                removeWaiter(q);
                throw new InterruptedException();
            }
            int s = state;
            if (s > COMPLETING) {//task已經結束
                if (q != null)
                    q.thread = null;
                return s;
            }
            //第二個執行緒進來，正在執行，發現前面有等待節點，則讓出cpu
            else if (s == COMPLETING) // cannot time out yet
                Thread.yield();
            // 第一次遍歷，初始化 WaitNode，第一個節點進來時進行，第一個執行緒狀態是new
            else if (q == null)
                q = new WaitNode();
             // 是否已入隊，沒有則把WaitNode接到末尾，第一個執行緒第二次遍歷時執行下面程式碼
            else if (!queued)
                // 和 finishCompletion 和 removeWaiter 競爭
                // 1. finishCompletion競爭成功，說明state已經 > COMPLETING則下次迴圈就會退出
                // 2. removeWaiter競爭成功，說明waiters變化了，下一次迴圈再次競爭
                queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
                                                     q.next = waiters, q);
            // 如果使用了計時，則判斷是否超時，如果超時則移出WaitNode並立即返回無需等待結果，否則阻塞 nanos
            else if (timed) {
                nanos = deadline - System.nanoTime();
                if (nanos <= 0L) {
                    removeWaiter(q);
                    return state;
                }
                LockSupport.parkNanos(this, nanos);
            }
            else
                //阻塞，直到被喚醒（正常完成 || 異常 || 中斷）
                LockSupport.park(this);
        }
    }
    //根據awaitDone返回狀態返回結果或丟擲異常
    private V report(int s) throws ExecutionException {
        Object x = outcome;
        if (s == NORMAL)//正常
            return (V)x;
        if (s >= CANCELLED)//取消
            throw new CancellationException();
        // task 執行過程中出現異常
        throw new ExecutionException((Throwable)x);
    }

    removeWaiter：

        /**
         * Tries to unlink a timed-out or interrupted wait node to avoid
         * accumulating garbage.  Internal nodes are simply unspliced
         * without CAS since it is harmless if they are traversed anyway
         * by releasers.  To avoid effects of unsplicing from already
         * removed nodes, the list is retraversed in case of an apparent
         * race.  This is slow when there are a lot of nodes, but we don't
         * expect lists to be long enough to outweigh higher-overhead
         * schemes.
         *嘗試取消連結超時或中斷的等待節點以避免堆積垃圾。內部節點的拼接沒有CAS，
         *因為這對釋放者無論如何遍歷都沒有影響。 為了避免已刪除節點節點未拼接的影響，
         *如果出現明顯的競爭，則重新遍歷列表。 當節點很多時會很慢，但是我們不
         *期望列表足夠長以抵消較高的開銷計劃。
         */
    private void removeWaiter(WaitNode node) {
        if (node != null) {
            node.thread = null;
            retry:
            for (;;) {          // restart on removeWaiter race
                //遍歷整個連結串列
                for (WaitNode pred = null, q = waiters, s; q != null; q = s) {
                    s = q.next;
                    //把q當作前一個節點，遍歷下一個節點
                    if (q.thread != null)
                        pred = q;
                     // q.thread == null && pred != null，表示當前節點不是第一個節點，是一箇中間節點
                     // 這裡沒有使用 CAS，如果出現多個執行緒同時遍歷，前一個節點變為null，則重新從頭遍歷
                     // 為什麼沒有使用 CAS 因為作者的想法是這個連結串列不會太長，所以我們使用時不應該使這個連結串列太長
                     // 操作：把下一個節點連線到前一個節點的後面
                    else if (pred != null) {
                        pred.next = s;//把s連線到pred後面
                        if (pred.thread == null) // check for race
                            continue retry;
                    }
                    // q.thread == null && pred == null，表示第一個節點的 thread == null，
                    // 這裡使用 CAS，因為可能多個執行緒在操作
                    // 操作：把下一個節點設定為末尾節點，如果競爭失敗則重新從頭遍歷
                    else if (!UNSAFE.compareAndSwapObject(this, waitersOffset,
                                                          q, s))
                        continue retry;
                }
                break;
            }
        }
    }

     isDone：

        public boolean isDone() {
        return state != NEW;
    }

  3.  建立Thread，把FutureTask例項放入構造方法中，start開啟執行緒

 參考：https://www.jianshu.com/p/414cc2f0

相關推薦

多執行緒高併發程式設計(7) -- Future原始碼分析

一.概念 　　A Future計算的結果。 提供方法來檢查計算是否完成，等待其完成，並檢索計算結果。 結果只能在計算完成後使用方法get進行檢索，如有必要，阻塞，直到準備就緒。 取消由cancel方法執行。 提供其他方法來確定任務是否正常完成或被取消。 計算完成後，不能取消計算。 如果您想使用Future ，

多執行緒高併發程式設計(3) -- ReentrantLock原始碼分析AQS

背景： 　　AbstractQueuedSynchronizer(AQS) public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements java.io.Seri

多執行緒高併發程式設計(10) -- ConcurrentHashMap原始碼分析

　　一.背景 　　前文講了HashMap的原始碼分析，從中可以看到下面的問題： HashMap的put/remove方法不是執行緒安全的，如果在多執行緒併發環境下，使用synchronized進行加鎖，會導致效率低下； 在遍歷迭代獲取時進行修改(put/remove)操作，會導致發生併發修改異常(Concu

多執行緒高併發程式設計(1) -- 基礎及詳解

背景： 　　程序和執行緒的區別： 　　程序的記憶體大小為：堆記憶體+執行緒數量*棧記憶體，即執行緒數量 =（ 最大地址空間[MaxProcessMemory] - JVM堆記憶體 - 系統保留記憶體[ReservedOsMemory] ）/ ThreadStackSize(XSS)，從中可以看出，執行緒的數

多執行緒高併發程式設計(5) -- CountDownLatch、CyclicBarrier原始碼分析

一.CountDownLatch 　　1.概念 public CountDownLatch(int count) {//初始化 if (count < 0) throw new IllegalArgumentException("count < 0");

多執行緒高併發程式設計(6) -- Semaphere、Exchanger原始碼分析

一.Semaphere 　　1.概念 　　一個計數訊號量。在概念上，訊號量維持一組許可證。如果有必要，每個acquire()都會阻塞，直到許可證可用，然後才能使用它。每個release()新增許可證，潛在地釋放阻塞獲取方。但是，沒有使用實際的許可證物件;Semaphore只保留可用數量的計數，並相應地執行。

多執行緒高併發程式設計(8) -- Fork/Join原始碼分析

一.概念 　　Fork/Join就是將一個大任務分解(fork)成許多個獨立的小任務，然後多執行緒並行去處理這些小任務，每個小任務處理完得到結果再進行合併(join)得到最終的結果。 　　流程：任務繼承RecursiveTask，重寫compute方法，使用ForkJoinPool的submit提交任務，任

多執行緒高併發程式設計(9) -- CopyOnWrite寫入時複製

　　CopyOnWrite寫入時複製 　　CopyOnWrite，即快照模式，寫入時複製就是不同執行緒訪問同一資源的時候，會獲取相同的指標指向這個資源，只有在寫操作，才會去複製一份新的資料，然後新的資料在被寫操作完後立馬被其他執行緒看到最新的資料變化，然後之前獲取的指標會指向新的資料，但在寫操作未結束時，其他

多執行緒高併發程式設計(11) -- 非阻塞演算法實現ConcurrentLinkedQueue原始碼分析

　　一.背景 　　要實現對佇列的安全訪問，有兩種方式：阻塞演算法和非阻塞演算法。阻塞演算法的實現是使用一把鎖（出隊和入隊同一把鎖ArrayBlockingQueue）和兩把鎖（出隊和入隊各一把鎖LinkedBlockingQueue）來實現；非阻塞演算法使用自旋+CAS實現。 　　今天來探究下使用非阻塞演算法

多執行緒高併發程式設計(12) -- 阻塞演算法實現ArrayBlockingQueue原始碼分析（1）

一.前言 　　前文探究了非阻塞演算法的實現ConcurrentLinkedQueue安全佇列，也說明了阻塞演算法實現的兩種方式，使用一把鎖（出隊和入隊同一把鎖ArrayBlockingQueue）和兩把鎖（出隊和入隊各一把鎖LinkedBlockingQueue）來實現，今天來探究下ArrayBlocking

多執行緒高併發程式設計(12) -- 阻塞演算法實現ArrayBlockingQueue原始碼分析

一.前言 　　前文探究了非阻塞演算法的實現ConcurrentLinkedQueue安全佇列，也說明了阻塞演算法實現的兩種方式，使用一把鎖（出隊和入隊同一把鎖ArrayBlockingQueue）和兩把鎖（出隊和入隊各一把鎖LinkedBlockingQueue）來實現，今天來探究下ArrayBlocking

SpringBoot實戰實現分散式鎖一之重現多執行緒高併發場景

實戰前言：上篇博文我總體介紹了我這套視訊課程：“SpringBoot實戰實現分散式鎖” 總體涉及的內容，從本篇文章開始，我將開始介紹其中涉及到的相關知識要點，感興趣的小夥伴可以關注關注學習學習！！工欲善其事，必先利其器，介紹分散式鎖使用的前因後果之前，得先想辦法說清楚為啥需要分散式鎖以及

多執行緒與併發程式設計

前言 多執行緒併發程式設計是Java程式設計中重要的一塊內容，也是面試重點覆蓋區域，所以學好多執行緒併發程式設計對我們來說極其重要，下面跟我一起開啟本次的學習之旅吧。 正文 執行緒與程序 1 執行緒：程序中負責程式執行的執行單元執行緒本身依靠程

Java 多執行緒高併發 1 — 幾個重要的概念

原子性： 和物理上的原子貌似沒多大關係，對於一系列的操作只能單個執行緒做處理，不能有其他執行緒干擾，例如多個人想往同一個杯子倒茶，但只有一個茶壺，只有等這個茶壺讓出來才能繼續讓其他人倒茶 有序性：

Java 多執行緒高併發 2 — CAS 無鎖

在 Java 併發程式設計裡面，最可愛的就是無鎖了，非常巧妙，精彩絕倫 額。O__O "… 那麼什麼是無鎖？ 顧名思義，在併發情況下采用無鎖的方式實現物件操作的原子性，保證資料一致性、安全性、正確性

Java 多執行緒高併發 3.3 — Semaphore 共享鎖使用

Semaphore 是共享鎖的一種，字面上意思就是訊號量鎖 顧名思義，一個可以共享的鎖，可以讓多個執行緒共享同一把鎖，例如同一條馬路可以讓 4 臺車同時並行跑，相當於可以讓 4 個執行緒共享一把鎖，臨

Java 多執行緒高併發 3.5 — ReadWriteLock 讀寫鎖使用

ReadWriteLock 又稱為共享鎖，的讀寫分離鎖，內部分為讀鎖和寫鎖 關於 A 和 B 執行緒，讀和寫的關係 A 讀 — B 讀：不互斥、不阻塞 A 讀 — B 寫：互斥，互相阻塞 A 寫 — B 寫：互斥，互相阻塞 用法：非常簡單，和 Reentra

java執行緒高併發程式設計

權宣告：本文為博主原創文章，未經博主允許不得轉載。    https://blog.csdn.net/LiuRenyou/article/details/72805889 java執行緒詳解及高併發程式設計庖丁解牛 執行緒概述： 祖宗： 說起java高併發程式設計

java多執行緒高併發知識總結

1.      計算機系統 使用快取記憶體來作為記憶體與處理器之間的緩衝，將運算需要用到的資料複製到快取中，讓計算能快速進行；當運算結束後再從快取同步回記憶體之中，這樣處理器就無需等待緩慢的記憶體讀寫了。 快取一致性：多處理器系統中，因為共享同一主記憶體，

【多執行緒高併發】多執行緒的設計模式

多執行緒的設計模式 程式碼在Multi_004當中 並行設計模式屬於設計優化的一部分，他是對一些常用的多執行緒結構的總結和抽象，與序列程式相比，並行程式的結構通常更為複雜，因此合理的使用並行模式在多執行緒開發中更具有意義，在這裡主要介紹Futur