2. 程式人生 > >讓線程按順序執行8種方法

讓線程按順序執行8種方法

阿新 • • 發佈：2019-03-26
new 超過 需求 功能 並發 通過 流量 true throw

實現
我們下面需要完成這樣一個應用場景：

1.早上；2.測試人員、產品經理、開發人員陸續的來公司上班；3.產品經理規劃新需求；4.開發人員開發新需求功能；5.測試人員測試新功能。

規劃需求，開發需求新功能，測試新功能是一個有順序的，我們把thread1看做產品經理，thread2看做開發人員，thread3看做測試人員。

1.使用線程的join方法

join():是Theard的方法，作用是調用線程需等待該join()線程執行完成後，才能繼續用下運行。

如果想學習Java工程化、高性能及分布式、深入淺出。微服務、Spring，MyBatis，Netty源碼分析的朋友可以加我的Java高級交流：787707172，群裏有阿裏大牛直播講解技術，以及Java大型互聯網技術的視頻免費分享給大家。

應用場景：當一個線程必須等待另一個線程執行完畢才能執行時可以使用join方法。

package com.wwj.javabase.thread.order;
/**

  • @author wwj
  • 通過子程序join使線程按順序執行
    */
    public class ThreadJoinDemo {
    public static void main(String[] args) {
    final Thread thread1 = new Thread(new Runnable() {@Override
    br/>@Override
    System.out.println("產品經理規劃新需求");
    }
    });
    final Thread thread2 = new Thread(new Runnable() {@Override
    br/>@Override
    try {
    thread1.join();
    System.out.println("開發人員開發新需求功能");
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    }
    });
    Thread thread3 = new Thread(new Runnable() {@Override
    br/>@Override
    try {
    thread2.join();
    System.out.println("測試人員測試新功能");
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    }
    });
    System.out.println("早上：");
    System.out.println("測試人員來上班了...");
    thread3.start();
    System.out.println("產品經理來上班了...");
    thread1.start();
    System.out.println("開發人員來上班了...");
    thread2.start();
    }
    }
    運行結果

早上：
測試人員來上班了...
產品經理來上班了...
開發人員來上班了...
產品經理規劃新需求
開發人員開發新需求功能
測試人員測試新功能
2.使用主線程的join方法

這裏是在主線程中使用join()來實現對線程的阻塞。

package com.wwj.javabase.thread.order;
/**

  • @author wwj
  • 通過主程序join使線程按順序執行
    */
    public class ThreadMainJoinDemo {
    public static void main(String[] args) throws Exception {
    final Thread thread1 = new Thread(new Runnable() {@Override
    br/>@Override
    System.out.println("產品經理正在規劃新需求...");
    }
    });
    final Thread thread2 = new Thread(new Runnable() {@Override
    br/>@Override
    System.out.println("開發人員開發新需求功能");
    }
    });
    final Thread thread3 = new Thread(new Runnable() {@Override
    br/>@Override
    System.out.println("測試人員測試新功能");
    }
    });
    System.out.println("早上:");
    System.out.println("產品經理來上班了");
    System.out.println("測試人員來上班了");
    System.out.println("開發人員來上班了");
    thread1.start();
    //在父進程調用子進程的join()方法後，父進程需要等待子進程運行完再繼續運行。
    System.out.println("開發人員和測試人員休息會...");
    thread1.join();
    System.out.println("產品經理新需求規劃完成!");
    thread2.start();
    System.out.println("測試人員休息會...");
    thread2.join();
    thread3.start();
    }
    }
    運行結果

產品經理來上班了
測試人員來上班了
開發人員來上班了
開發人員和測試人員休息會...
產品經理正在規劃新需求...
產品經理新需求規劃完成!
測試人員休息會...
開發人員開發新需求功能
測試人員測試新功能
3.使用線程的wait方法

wait():是Object的方法，作用是讓當前線程進入等待狀態，同時，wait()也會讓當前線程釋放它所持有的鎖。“直到其他線程調用此對象的 notify() 方法或 notifyAll() 方法”，當前線程被喚醒(進入“就緒狀態”)

notify()和notifyAll():是Object的方法，作用則是喚醒當前對象上的等待線程；notify()是喚醒單個線程，而notifyAll()是喚醒所有的線程。

wait(long timeout):讓當前線程處於“等待(阻塞)狀態”，“直到其他線程調用此對象的notify()方法或 notifyAll() 方法，或者超過指定的時間量”，當前線程被喚醒(進入“就緒狀態”)。

應用場景：Java實現生產者消費者的方式。

package com.wwj.javabase.thread.order;
/**

  • @author wwj
    */
    public class ThreadWaitDemo {
    private static Object myLock1 = new Object();
    private static Object myLock2 = new Object();
    /**
  • 為什麽要加這兩個標識狀態?
  • 如果沒有狀態標識，當t1已經運行完了t2才運行，t2在等待t1喚醒導致t2永遠處於等待狀態
    */
    private static Boolean t1Run = false;
    private static Boolean t2Run = false;
    public static void main(String[] args) {
    final Thread thread1 = new Thread(new Runnable() {@Override
    br/>@Override
    synchronized (myLock1){
    System.out.println("產品經理規劃新需求...");
    t1Run = true;
    myLock1.notify();
    }
    }
    });
    final Thread thread2 = new Thread(new Runnable() {@Override
    br/>@Override
    synchronized (myLock1){
    try {
    if(!t1Run){
    System.out.println("開發人員先休息會...");
    myLock1.wait();
    }
    synchronized (myLock2){
    System.out.println("開發人員開發新需求功能");
    myLock2.notify();
    }
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    }
    }
    });
    Thread thread3 = new Thread(new Runnable() {@Override
    br/>@Override
    synchronized (myLock2){
    try {
    if(!t2Run){
    System.out.println("測試人員先休息會...");
    myLock2.wait();
    }
    System.out.println("測試人員測試新功能");
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    }
    }
    });
    System.out.println("早上：");
    System.out.println("測試人員來上班了...");
    thread3.start();
    System.out.println("產品經理來上班了...");
    thread1.start();
    System.out.println("開發人員來上班了...");
    thread2.start();
    }
    }
    運行結果:這裏輸出會有很多種順序，主要是因為線程進入的順序，造成鎖住線程的順序不一致。

早上：
測試人員來上班了...
產品經理來上班了...
開發人員來上班了...
測試人員先休息會...
產品經理規劃新需求...
開發人員開發新需求功能
測試人員測試新功能
4.使用線程的線程池方法

JAVA通過Executors提供了四種線程池

單線程化線程池(newSingleThreadExecutor);
可控最大並發數線程池(newFixedThreadPool);
可回收緩存線程池(newCachedThreadPool);
支持定時與周期性任務的線程池(newScheduledThreadPool)。
單線程化線程池(newSingleThreadExecutor):優點，串行執行所有任務。

submit()：提交任務。

shutdown()：方法用來關閉線程池，拒絕新任務。

應用場景:串行執行所有任務。如果這個唯一的線程因為異常結束，那麽會有一個新的線程來替代它。此線程池保證所有任務的執行順序按照任務的提交順序執行。

package com.wwj.javabase.thread.order;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**

  • @author wwj
  • 通過SingleThreadExecutor讓線程按順序執行
    */
    public class ThreadPoolDemo {
    static ExecutorService executorService = Executors.newSingleThreadExecutor();
    public static void main(String[] args) throws Exception {
    final Thread thread1 = new Thread(new Runnable() {@Override
    br/>@Override
    System.out.println("產品經理規劃新需求");
    }
    });
    final Thread thread2 = new Thread(new Runnable() {@Override
    br/>@Override
    System.out.println("開發人員開發新需求功能");
    }
    });
    Thread thread3 = new Thread(new Runnable() {@Override
    br/>@Override
    System.out.println("測試人員測試新功能");
    }
    });
    System.out.println("早上：");
    System.out.println("產品經理來上班了");
    System.out.println("測試人員來上班了");
    System.out.println("開發人員來上班了");
    System.out.println("領導吩咐:");
    System.out.println("首先，產品經理規劃新需求...");
    executorService.submit(thread1);
    System.out.println("然後，開發人員開發新需求功能...");
    executorService.submit(thread2);
    System.out.println("最後，測試人員測試新功能...");
    executorService.submit(thread3);
    executorService.shutdown();
    }
    }
    運行結果

早上：
產品經理來上班了
測試人員來上班了
開發人員來上班了
領導吩咐:
首先，產品經理規劃新需求...
然後，開發人員開發新需求功能...
最後，測試人員測試新功能...
產品經理規劃新需求
開發人員開發新需求功能
測試人員測試新功能
5.使用線程的Condition(條件變量)方法

Condition（條件變量）:通常與一個鎖關聯。需要在多個Contidion中共享一個鎖時，可以傳遞一個Lock/RLock實例給構造方法，否則它將自己生成一個RLock實例。

Condition中await()方法類似於Object類中的wait()方法。
Condition中await(long time,TimeUnit unit)方法類似於Object類中的wait(long time)方法。
Condition中signal()方法類似於Object類中的notify()方法。
Condition中signalAll()方法類似於Object類中的notifyAll()方法。
應用場景：Condition是一個多線程間協調通信的工具類，使得某個，或者某些線程一起等待某個條件（Condition）,只有當該條件具備( signal 或者 signalAll方法被帶調用)時 ，這些等待線程才會被喚醒，從而重新爭奪鎖。

package com.wwj.javabase.thread.order;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**

  • @author wwj
  • 使用Condition(條件變量)實現線程按順序運行
    */
    public class ThreadConditionDemo {
    private static Lock lock = new ReentrantLock();
    private static Condition condition1 = lock.newCondition();
    private static Condition condition2 = lock.newCondition();
    /**
  • 為什麽要加這兩個標識狀態?
  • 如果沒有狀態標識，當t1已經運行完了t2才運行，t2在等待t1喚醒導致t2永遠處於等待狀態
    */
    private static Boolean t1Run = false;
    private static Boolean t2Run = false;
    public static void main(String[] args) {
    final Thread thread1 = new Thread(new Runnable() {@Override
    br/>@Override
    lock.lock();
    System.out.println("產品經理規劃新需求");
    t1Run = true;
    condition1.signal();
    lock.unlock();
    }
    });
    final Thread thread2 = new Thread(new Runnable() {@Override
    br/>@Override
    lock.lock();
    try {
    if(!t1Run){
    System.out.println("開發人員先休息會...");
    condition1.await();
    }
    System.out.println("開發人員開發新需求功能");
    t2Run = true;
    condition2.signal();
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    lock.unlock();
    }
    });
    Thread thread3 = new Thread(new Runnable() {@Override
    br/>@Override
    lock.lock();
    try {
    if(!t2Run){
    System.out.println("測試人員先休息會...");
    condition2.await();
    }
    System.out.println("測試人員測試新功能");
    lock.unlock();
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    }
    });
    System.out.println("早上：");
    System.out.println("測試人員來上班了...");
    thread3.start();
    System.out.println("產品經理來上班了...");
    thread1.start();
    System.out.println("開發人員來上班了...");
    thread2.start();
    }
    }
    運行結果:這裏輸出會有很多種順序，主要是因為線程進入的順序，造成鎖住線程的順序不一致

早上：
測試人員來上班了...
產品經理來上班了...
開發人員來上班了...
測試人員先休息會...
產品經理規劃新需求
開發人員開發新需求功能
測試人員測試新功能
6.使用線程的CountDownLatch（倒計數）方法

CountDownLatch:位於java.util.concurrent包下，利用它可以實現類似計數器的功能。

應用場景:比如有一個任務C，它要等待其他任務A,B執行完畢之後才能執行，此時就可以利用CountDownLatch來實現這種功能了。

package com.wwj.javabase.thread.order;
import java.util.concurrent.CountDownLatch;
/**

  • @author wwj
  • 通過CountDownLatch（倒計數）使線程按順序執行
    */
    public class ThreadCountDownLatchDemo {
    /**
  • 用於判斷線程一是否執行，倒計時設置為1，執行後減1
    */
    private static CountDownLatch c1 = new CountDownLatch(1);
    /**
  • 用於判斷線程二是否執行，倒計時設置為1，執行後減1
    */
    private static CountDownLatch c2 = new CountDownLatch(1);
    public static void main(String[] args) {
    final Thread thread1 = new Thread(new Runnable() {@Override
    br/>@Override
    System.out.println("產品經理規劃新需求");
    //對c1倒計時-1
    c1.countDown();
    }
    });
    final Thread thread2 = new Thread(new Runnable() {@Override
    br/>@Override
    try {
    //等待c1倒計時，計時為0則往下運行
    c1.await();
    System.out.println("開發人員開發新需求功能");
    //對c2倒計時-1
    c2.countDown();
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    }
    });
    Thread thread3 = new Thread(new Runnable() {@Override
    br/>@Override
    try {
    //等待c2倒計時，計時為0則往下運行
    c2.await();
    System.out.println("測試人員測試新功能");
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    }
    });
    System.out.println("早上：");
    System.out.println("測試人員來上班了...");
    thread3.start();
    System.out.println("產品經理來上班了...");
    thread1.start();
    System.out.println("開發人員來上班了...");
    thread2.start();
    }
    }
    運行結果

早上：
測試人員來上班了...
產品經理來上班了...
開發人員來上班了...
產品經理規劃新需求
開發人員開發新需求功能
測試人員測試新功能
7.使用CyclicBarrier(回環柵欄)實現線程按順序運行

CyclicBarrier(回環柵欄):通過它可以實現讓一組線程等待至某個狀態之後再全部同時執行。叫做回環是因為當所有等待線程都被釋放以後，CyclicBarrier可以被重用。我們暫且把這個狀態就叫做barrier，當調用await()方法之後，線程就處於barrier了。

如果想學習Java工程化、高性能及分布式、深入淺出。微服務、Spring，MyBatis，Netty源碼分析的朋友可以加我的Java高級交流：787707172，群裏有阿裏大牛直播講解技術，以及Java大型互聯網技術的視頻免費分享給大家。

應用場景:公司組織春遊,等待所有的員工到達集合地點才能出發，每個人到達後進入barrier狀態。都到達後，喚起大家一起出發去旅行。

package com.wwj.javabase.thread.order;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
/**

  • @author wwj
  • 使用CyclicBarrier(回環柵欄)實現線程按順序運行
    */
    public class CyclicBarrierDemo {
    static CyclicBarrier barrier1 = new CyclicBarrier(2);
    static CyclicBarrier barrier2 = new CyclicBarrier(2);
    public static void main(String[] args) {
    final Thread thread1 = new Thread(new Runnable() {@Override
    br/>@Override
    try {
    System.out.println("產品經理規劃新需求");
    //放開柵欄1
    barrier1.await();
    } catch (InterruptedException e) {
    e.printStackTrace();
    } catch (BrokenBarrierException e) {
    e.printStackTrace();
    }
    }
    });
    final Thread thread2 = new Thread(new Runnable() {@Override
    br/>@Override
    try {
    //放開柵欄1
    barrier1.await();
    System.out.println("開發人員開發新需求功能");
    //放開柵欄2
    barrier2.await();
    } catch (InterruptedException e) {
    e.printStackTrace();
    } catch (BrokenBarrierException e) {
    e.printStackTrace();
    }
    }
    });
    final Thread thread3 = new Thread(new Runnable() {@Override
    br/>@Override
    try {
    //放開柵欄2
    barrier2.await();
    System.out.println("測試人員測試新功能");
    } catch (InterruptedException e) {
    e.printStackTrace();
    } catch (BrokenBarrierException e) {
    e.printStackTrace();
    }
    }
    });
    System.out.println("早上：");
    System.out.println("測試人員來上班了...");
    thread3.start();
    System.out.println("產品經理來上班了...");
    thread1.start();
    System.out.println("開發人員來上班了...");
    thread2.start();
    }
    }
    運行結果

早上：
測試人員來上班了...
產品經理來上班了...
開發人員來上班了...
產品經理規劃新需求
開發人員開發新需求功能
測試人員測試新功能
8.使用Sephmore(信號量)實現線程按順序運行

Sephmore(信號量):Semaphore是一個計數信號量,從概念上將，Semaphore包含一組許可證,如果有需要的話，每個acquire()方法都會阻塞，直到獲取一個可用的許可證,每個release()方法都會釋放持有許可證的線程，並且歸還Semaphore一個可用的許可證。然而，實際上並沒有真實的許可證對象供線程使用，Semaphore只是對可用的數量進行管理維護。

acquire():當前線程嘗試去阻塞的獲取1個許可證,此過程是阻塞的,當前線程獲取了1個可用的許可證，則會停止等待，繼續執行。

release():當前線程釋放1個可用的許可證。

應用場景:Semaphore可以用來做流量分流，特別是對公共資源有限的場景，比如數據庫連接。假設有這個的需求，讀取幾萬個文件的數據到數據庫中，由於文件讀取是IO密集型任務，可以啟動幾十個線程並發讀取，但是數據庫連接數只有10個，這時就必須控制最多只有10個線程能夠拿到數據庫連接進行操作。這個時候，就可以使用Semaphore做流量控制。

package com.wwj.javabase.thread.order;
import java.util.concurrent.Semaphore;
/**

  • @author wwj
  • 使用Sephmore(信號量)實現線程按順序運行
    */
    public class SemaphoreDemo {
    private static Semaphore semaphore1 = new Semaphore(1);
    private static Semaphore semaphore2 = new Semaphore(1);
    public static void main(String[] args) {
    final Thread thread1 = new Thread(new Runnable() {@Override
    br/>@Override
    System.out.println("產品經理規劃新需求");
    semaphore1.release();
    }
    });
    final Thread thread2 = new Thread(new Runnable() {@Override
    br/>@Override
    try {
    semaphore1.acquire();
    System.out.println("開發人員開發新需求功能");
    semaphore2.release();
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    }
    });
    Thread thread3 = new Thread(new Runnable() {@Override
    br/>@Override
    try {
    semaphore2.acquire();
    thread2.join();
    semaphore2.release();
    System.out.println("測試人員測試新功能");
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    }
    });
    System.out.println("早上：");
    System.out.println("測試人員來上班了...");
    thread3.start();
    System.out.println("產品經理來上班了...");
    thread1.start();
    System.out.println("開發人員來上班了...");
    thread2.start();
    }
    }
    運行結果

早上：
測試人員來上班了...
產品經理來上班了...
開發人員來上班了...
產品經理規劃新需求
開發人員開發新需求功能
測試人員測試新功能
總結
看完了這麽多種方法，是不是對多線程有了更深入的了解呢?不妨自己試試吧(代碼拷貝均可運行)

使用的場景還有很多，根據開發需求場景，選擇合適的方法，達到事半功倍的效果。

歡迎工作一到八年的Java工程師朋友們加入Java高級交流：787707172

本群提供免費的學習指導 架構資料 以及免費的解答

不懂得問題都可以在本群提出來 之後還會有直播平臺和講師直接交流噢

讓線程按順序執行8種方法

相關推薦

讓線程按順序執行8種方法

new 超過 需求 功能 並發 通過 流量 true throw 實現我們下面需要完成這樣一個應用場景： 1.早上；2.測試人員、產品經理、開發人員陸續的來公司上班；3.產品經理規劃新需求；4.開發人員開發新需求功能；5.測試人員測試新功能。 規劃需求，開發需求新功能，測試

條件變量模式-讓線程根據條件執行

阻塞 其它 互斥 clas cpu enter bsp pat 自己 1 /// <summary> 2 /// 條件變量模式 3 /// 讓線程根據條件執行 4 /// </summary> 5

線程的啟動的兩種方法，Runnable接口，run（）的調用

ride 之前 線程終止 源碼解析 star 有意 tro thread類 override 實現並啟動線程有兩種方法1、寫一個類繼承自Thread類，重寫run方法。用start方法啟動線程2、寫一個類實現Runnable接口，實現run方法。用new Thread(Ru

線程創建的第二種方法

private str 繼承 run方法 string pri light imp 今天 第一種方法是繼承並且重寫run方法（不推薦使用） 第二種就是有爹的情況，用實現接口的形式拓展功能——實現Runnable接口 Runnable中只有run（）方法 今天復習同步線程

c++11線程創建的三種方法

pch pan 銷毀 表達 tac 回收 系統 urn 執行 一、用一個初始函數創建一個線程 直接看代碼：註意c++在運行一個可執行程序的時候（創建了一個進程），會自動的創建一個主線程，這個主線程和進程同生共死，主線程結束，進程也就結束了。 1 #include

Thread類的sleep()方法和對象的wait()方法都可以讓線程暫停執行，它們有什麽區別? 線程的sleep()方法和yield()方法有什麽區別？

阻塞 可移植性 喚醒 ora 暫停 obj 狀態 ati 對象 Thread類的sleep()方法和對象的wait()方法都可以讓線程暫停執行，它們有什麽區別? 　　sleep()方法（休眠）是線程類（Thread）的靜態方法，調用此方法會讓當前線程暫停執行指定的時間，將執

【分析】淺談C#中Control的Invoke與BeginInvoke在主副線程中的執行順序和區別（SamWang）

info start result 初步 總結 inter blank rap 傳遞 　　今天無意中看到有關Invoke和BeginInvoke的一些資料，不太清楚它們之間的區別。所以花了點時間研究了下。 　　據msdn中介紹，它們最大的區別就是BeginInvoke屬於

join()之讓執行緒按順序執行

Thread中的join() 主執行緒建立並啟動子執行緒，如果子執行緒中要進行大量的耗時運算，主執行緒往往將在子執行緒執行結束前結束。如果主執行緒想等待子執行緒執行完成後再結束（如，子執行緒處理一個數據，主執行緒需要取到這個值），則需要用到join()。

多執行緒和併發（三）使用join方法讓執行緒按順序執行

一.執行緒的join方法作用 join方法把指定的執行緒新增到當前執行緒中，可以不給引數直接thread.join（），也可以給一個時間引數，單位為毫秒thread.join（500）。事實上join方法是通過wait方法來實現的。比如執行緒A中加入了執行緒B.join方法

兩個線程，交替執行

rac notify zed 等待 main java exc start system import java.util.*; public class Main { static ArrayList<Integer> list=new ArrayL

Android線程間通訊的幾種方式

not asynctask gen andro ttext eth pub nbsp delayed 1.runOnUiThread(Runnable) 在子線程中直接使用該方法，可以更新UI runOnUiThread(new Runnable

_beginthreadex創建線程，立即執行？

code gin tro tab dex lpad mil and vertical 　　一個線程創建後，並不是立馬就執行，而是等時間片到來後才執行... C++ Code 123456789101112131415161718192021222324252

戲（細）說Executor框架線程池任務執行全過程（上）

文章 空間 重點 urn 枯燥 ash 成功 創建 使用 原文鏈接：http://ifeve.com/executor-framework-thread-pool-task-execution-part-01/ 內容綜述 基於Executor接口中將任務提交和任務執行解耦的

【java多線程】多線程的創建三種方式--筆記

admin auth nbsp 主線程 實現類 如果 nts 名稱 就是 申明：線程的概念以及進程的相關概念，可以參考網絡上其他資料，這裏只討論多線程是怎麽實現。 一、多線程的簡單理解 明白什麽是多線程，小生通俗一點的理解為：在一個程序裏，我想同時讓這個程序完成多個任務

一種WPF在後臺線程更新UI界面的簡便方法

bool static syn current strong 表示 pos 更新ui界面 幸好 WPF框架規定只有UI線程（主線程）可以更新界面，所有其他後臺線程無法直接更新界面。幸好，WPF提供的SynchronizationContext類以及C#的Lambda表達式提

多個線程實現順序打印數據，（可自定義線程一次打印數量和總數量）

技術分享 str logs ges his .get shm import pre 　　最近看到一道面試題：讓3個線程順序打印數字，如線程1打印1-5，線程2打印6-10，線程3打印11-15,然後是線程1打印16-20...一直打印到75結束。 　　這到題主要問題有兩點

Java並發編程：線程間協作的兩種方式：wait、notify、notifyAll和Condition

消費者 CI 能夠 .com stat consumer 使用 producer imp 原文鏈接 Java並發編程：線程間協作的兩種方式：wait、notify、notifyAll和Condition 在前面我們將了很多關於同步的問題，然而在現實中，需要線程之間的協作。比

控制只有3個線程同時完成後線程才能繼續執行

ava nal mat name dom random string ber rand import java.util.concurrent.CyclicBarrier; import java.util.concurrent.ExecutorService; impor

通過 Linux 系統線程查找 MySQL 8.0 進程的線程

lin thread mys mysqld ima term ads fcc ESS 查看 MySQL 進程 ID ps -ef | grep mysqld 查看 MySQL 的系統線程 top -Hp 14809 通過系統線程查看 MySQL 線程 select * fr

Junit4按順序執行test方法

pub jvm ring 類名 end eth 執行 int unit junit默認按方法名的按方法名的hashcode排序 若希望junit執行順序，可在類名上添加註解：@FixMethodOrder @FixMethodOrder接受MethodSorters