在很多時候，我們期望實現這麼一種功能：在主執行緒中啟動一些子執行緒，等待所有子執行緒執行結束後，主執行緒再繼續執行。比如：老闆分配任務，眾多工人開始工作，等所有工人完成工作後，老闆進行檢查。

解決方法分析：

1. 主執行緒通過join等待所有子執行緒完成後，繼續執行；
2. 主執行緒知道子執行緒的數量、未完成子執行緒數量，主執行緒等待所有子執行緒完成後，才繼續執行。

通過join實現

第一種方式，可以直接呼叫Java API中關於執行緒的join方法等待該執行緒終止，可以直接實現。

每個工人都是一個執行緒，其run方法是工作的實現，每個工人通過名字進行區分，具體程式碼如下：

package howe.demo.thread.join;


import java.util.Random;
import java.util.concurrent.TimeUnit;


/**
 * @author liuxinghao
 * @version 1.0 Created on 2014年9月12日
 */
public class Worker extends Thread {
    private String workerName;


    public Worker(String workerName) {
        this.workerName = workerName;
    }


    /**
     * @see java.lang.Thread#run()
     */
    @Override
    public void run() {
        System.out.println(this.workerName + "正在幹活...");
        try {
            TimeUnit.SECONDS.sleep(new Random().nextInt(10));
        } catch (InterruptedException e) {
        }
        System.out.println(this.workerName + "活幹完了！");
    }


    public String getWorkerName() {
        return workerName;
    }
}
 

老闆招收工人，然後安排工人工作，之後等待工人工作完，檢查工人的工作成果（資本家啊。。。），具體程式碼如下：

package howe.demo.thread.join;


import java.util.List;


/**
 * @author liuxinghao
 * @version 1.0 Created on 2014年9月12日
 */
public class Boss {
    private List<Worker> workers;


    public Boss(List<Worker> workers) {
        System.out.println("老闆招收工人。");
        this.workers = workers;
    }


    public void work() {
        System.out.println("老闆開始安排工人工作...");
        for (Worker worker : workers) {
            System.out.println("老闆安排" + worker.getWorkerName() + "的工作");
            worker.start();
        }
        System.out.println("老闆安排工作結束...");


        System.out.println("老闆正在等所有的工人幹完活......");
        for (Worker w : workers) {
            try {
                w.join();
            } catch (InterruptedException e) {
            }
        }
        System.out.println("工人活都幹完了，老闆開始檢查了！");
    }
}
 

現在寫main方法進行測試：

package howe.demo.thread.join;


import java.util.ArrayList;
import java.util.List;


/**
 * @author liuxinghao
 * @version 1.0 Created on 2014年9月12日
 */
public class JoinDemo {
    public static void main(String[] args) {
        Worker w1 = new Worker("張三");
        Worker w2 = new Worker("李四");
        Worker w3 = new Worker("王五");


        List<Worker> workers = new ArrayList<Worker>();
        workers.add(w1);
        workers.add(w2);
        workers.add(w3);


        Boss boss = new Boss(workers);
        boss.work();


        System.out.println("main方法結束");
    }
}
 

執行結果為：

老闆招收工人。
老闆開始安排工人工作...
老闆安排張三的工作
老闆安排李四的工作
張三正在幹活...
老闆安排王五的工作
李四正在幹活...
老闆安排工作結束...
老闆正在等所有的工人幹完活......
王五正在幹活...
王五活幹完了！
張三活幹完了！
李四活幹完了！
工人活都幹完了，老闆開始檢查了！
main方法結束

通過計數器實現

第二種方式可以自己實現一種計數器，用於統計子執行緒總數、未完成執行緒數，當未完成執行緒數大約0，主執行緒等待；當未完成執行緒數等於0，主執行緒繼續執行。

當然，既然我們現在想到這種方式，Java API的團隊當然也會想到，JDK 1.5提供了CountDownLatch用於實現上述方法。

於是對上述的工人方法進行修改：

package howe.demo.thread.cdl;


import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;


/**
 * @author liuxinghao
 * @version 1.0 Created on 2014-9-12
 */
public class Worker extends Thread {
    private CountDownLatch downLatch;
    private String workerName;


    public Worker(CountDownLatch downLatch, String workerName) {
        this.downLatch = downLatch;
        this.workerName = workerName;
    }


    public void run() {
        System.out.println(this.workerName + "正在幹活...");
        try {
            TimeUnit.SECONDS.sleep(new Random().nextInt(10));
        } catch (InterruptedException ie) {
        }
        System.out.println(this.workerName + "活幹完了！");
        this.downLatch.countDown();
    }


    public String getWorkerName() {
        return workerName;
    }
}

latch.countDown()，是用於在子執行緒執行結束後計數器減一，即未完成子執行緒數減一。

老闆類也得做出相應的修改：

package howe.demo.thread.cdl;


import java.util.List;
import java.util.concurrent.CountDownLatch;


/**
 * @author liuxinghao
 * @version 1.0 Created on 2014-9-12
 */
public class Boss {
    private List<Worker> workers;
    private CountDownLatch downLatch;


    public Boss(List<Worker> workers, CountDownLatch downLatch) {
        this.workers = workers;
        this.downLatch = downLatch;
    }


    public void work() {
        System.out.println("老闆開始安排工人工作...");
        for (Worker worker : workers) {
            System.out.println("老闆安排" + worker.getWorkerName() + "的工作");
            worker.start();
        }
        System.out.println("老闆安排工作結束...");


        System.out.println("老闆正在等所有的工人幹完活......");
        try {
            this.downLatch.await();
        } catch (InterruptedException e) {
        }
        System.out.println("工人活都幹完了，老闆開始檢查了！");
    }


}

latch.await()，是等待子執行緒結束。

編寫main方法進行驗證：

package howe.demo.thread.cdl;


import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;


/**
 * @author liuxinghao
 * @version 1.0 Created on 2014年9月15日
 */
public class CountDownLatchDemo {
    public static void main(String[] args) {
        CountDownLatch latch = new CountDownLatch(3);


        Worker w1 = new Worker(latch, "張三");
        Worker w2 = new Worker(latch, "李四");
        Worker w3 = new Worker(latch, "王五");


        List<Worker> workers = new ArrayList<Worker>();
        workers.add(w1);
        workers.add(w2);
        workers.add(w3);


        Boss boss = new Boss(workers, latch);


        boss.work();


        System.out.println("main方法結束");
    }
}

執行結果為：

老闆開始安排工人工作...
老闆安排張三的工作
老闆安排李四的工作
張三正在幹活...
老闆安排王五的工作
李四正在幹活...
老闆安排工作結束...
老闆正在等所有的工人幹完活......
王五正在幹活...
王五活幹完了！
李四活幹完了！
張三活幹完了！
工人活都幹完了，老闆開始檢查了！
main方法結束

使用迴圈柵欄CyclicBarrier實現

還有一種實現，這種方式不會阻塞主執行緒，但是會監聽所有子執行緒結束。此處在上述的工人老闆的場景中使用的話，程式碼如下：

工人類：

package howe.demo.thread.cyclicbarrier;


import java.util.Random;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeUnit;


/**
 * @author liuxinghao
 * @version 1.0 Created on 2014年9月12日
 */
public class Worker extends Thread {
    private String workerName;
    private CyclicBarrier barrier;


    public Worker(String workerName, CyclicBarrier barrier) {
        this.workerName = workerName;
        this.barrier = barrier;
    }


    @Override
    public void run() {
        System.out.println(this.workerName + "正在幹活...");
        try {
            TimeUnit.SECONDS.sleep(new Random().nextInt(10));
        } catch (InterruptedException e) {
        }
        System.out.println(this.workerName + "活幹完了！");


        try {
            barrier.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
    }


    public String getWorkerName() {
        return workerName;
    }
}

老闆類：

package howe.demo.thread.cyclicbarrier;


import java.util.List;


/**
 * @author liuxinghao
 * @version 1.0 Created on 2014-9-12
 */
public class Boss {
    private List<Worker> workers;


    public Boss(List<Worker> workers) {
        this.workers = workers;
    }


    public void work() {
        System.out.println("老闆開始安排工人工作...");
        for (Worker worker : workers) {
            System.out.println("老闆安排" + worker.getWorkerName() + "的工作");
            worker.start();
        }
        System.out.println("老闆安排工作結束...");


        System.out.println("老闆正在等所有的工人幹完活......");
    }


}

main方法測試：

package howe.demo.thread.cyclicbarrier;


import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CyclicBarrier;


/**
 * @author liuxinghao
 * @version 1.0 Created on 2014年9月15日
 */
public class CyclicBarrierDemo {
    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(3, new Runnable() {
            @Override
            public void run() {
                System.out.println("工人活都幹完了，老闆開始檢查了！");
            }
        });


        Worker w1 = new Worker("張三", barrier);
        Worker w2 = new Worker("李四", barrier);
        Worker w3 = new Worker("王五", barrier);


        List<Worker> workers = new ArrayList<Worker>();
        workers.add(w1);
        workers.add(w2);
        workers.add(w3);


        Boss boss = new Boss(workers);
        boss.work();


        System.out.println("main方法結束");
    }
}

執行結果為：

老闆開始安排工人工作...
老闆安排張三的工作
老闆安排李四的工作
張三正在幹活...
老闆安排王五的工作
李四正在幹活...
老闆安排工作結束...
老闆正在等所有的工人幹完活......
王五正在幹活...
main方法結束
李四活幹完了！
王五活幹完了！
張三活幹完了！
工人活都幹完了，老闆開始檢查了！

通過結果分析可以很清楚的看出，boss物件的work方法執行結束後，main方法即開始執行。（此處“老闆正在等所有的工人幹完活......”列印之後是“王五正在幹活...”，然後才是“main方法結束”，是因為對於cpu的搶佔，甚至有一定的概率是“main方法結束”會在最後列印。）

假設有這麼一個功能，我們需要向資料庫批量寫入一些記錄，然後記錄這個操作使用的時間，但是我們又不想影響其他操作（即不想阻塞主執行緒），這個時候CyclicBarrier就派上用場了。