等待某（N）个线程执行完再执行某个线程的几种方法（Thread.join(),CountDownLatch,CyclicBarrier,Semaphore）

1.main线程中先调用threadA.join() ，再调用threadB.join()实现A->B->main线程的执行顺序

 调用threadA.join()时，main线程会挂起，等待threadA执行完毕返回后再执行，到执行threadB.join()时再挂起，待threadB执行完毕返回继续执行main

使用场景：线程B依赖线程A的计算结果的场景

package concurrency;

public class JoinTest {
    public static void main(String[] args) throws InterruptedException{
        Thread threadA = new Thread(new JoinJob(),"thread-A");
        Thread threadB = new Thread(new JoinJob(),"thread-B");
        threadB.start();
        threadA.start();
        threadA.join();
        threadB.join();
        
        System.out.println("main ending...");
    }
}

class JoinJob implements Runnable{
    
    @Override
    public void run() {
        System.err.println(Thread.currentThread().getName() + " starting...");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " ending...");
        
    }
    
}

运行结果

2.CountDownLatch

使用场景：多线程数据计算时需要先分几个线程计算第一步骤的数据，再合并一个线程计算第二步

package concurrency;

import java.util.concurrent.CountDownLatch;

public class CountDownLatchTest {
    static CountDownLatch c = new CountDownLatch(6);//如果count大于实际线程数，c.await()会一直等待
    
    public static void main(String[] args) throws InterruptedException{
        for (int i = 0; i < c.getCount()/2; i++) {
            new Thread(new CountDownJob(c)).start();
            new Thread(new CountDownLatchJob2(c)).start();
            
        }
        
        System.out.println("waiting " + c.getCount() + " subthread doing");
        c.await();//await()会等待c的count值为0，才继续往下执行
        System.out.println("all subthread done!");
        System.out.println(Thread.currentThread().getName() + " done!");
    }
}

class CountDownJob implements Runnable{
    CountDownLatch cDownLatch;
    
    public CountDownJob(CountDownLatch cDownLatch) {
        super();
        this.cDownLatch = cDownLatch;
    }

    @Override
    public void run() {
        try {
            System.out.println(Thread.currentThread().getName() + " is doing something...");
            Thread.sleep(3000);
            cDownLatch.countDown();//线程结束时cDownLatch-1
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    
    }
    
}
class CountDownLatchJob2 implements Runnable{
    CountDownLatch cDownLatch;
    
    public CountDownLatchJob2(CountDownLatch cDownLatch) {
        super();
        this.cDownLatch = cDownLatch;
    }
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            System.err.println("thread sleep exception");
        }
        System.out.println(Thread.currentThread().getName() + " is doing something");
        cDownLatch.countDown();//线程结束时cDownLatch-1
    }
    
}

运行结果：

3.可循环使用的同步屏障CyclicBarrier

使用场景：多线程计算数据，等待全部线程执行完阶段一的工作之后，再执行后面的阶段工作

package concurrency;

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

public class CyclicBarrierTest {
    public static void main(String[] args) throws InterruptedException, BrokenBarrierException{
        CyclicBarrier cBarrier = new CyclicBarrier(6);
        //CyclicBarrier 提供另一个构造函数传入所有线程执行完后需要执行的runnable
//        CyclicBarrier cBarrier = new CyclicBarrier(6, new Runnable() {
//            
//            @Override
//            public void run() {
//                System.out.println("doing something after all threads done.");
//            }
//        });
        for (int i = 0; i < cBarrier.getParties()/2; i++) {
            new Thread(new CyclicBarrierJob1(cBarrier)).start();
            new Thread(new CyclicBarrierJob2(cBarrier)).start();
        }
        //CyclicBarrier 可以重置再次使用，如计算发生错误时可以重置计数器，并让线程重新执行一次。
        //而CountDownLatch只可以使用一次
        //cBarrier.reset();
    }
}

class CyclicBarrierJob1 implements Runnable {
    CyclicBarrier cBarrier;
    
    public CyclicBarrierJob1(CyclicBarrier cBarrier) {
        super();
        this.cBarrier = cBarrier;
    }

    public void run() {
        System.out.println(Thread.currentThread().getName() + " finished phase1");
        try {
            cBarrier.await();//执行完阶段1的工作之后，等待其他线程全部执行完阶段1，才会继续执行阶段二
        } catch (InterruptedException e) {
            System.err.println("interrupted!");
        } catch (BrokenBarrierException e) {
            System.err.println("broken barrier!");
        }
        
        System.out.println(Thread.currentThread().getName() + " start phase2");
    }
}
class CyclicBarrierJob2 implements Runnable {
    CyclicBarrier cBarrier;
    
    public CyclicBarrierJob2(CyclicBarrier cBarrier) {
        super();
        this.cBarrier = cBarrier;
    }
    
    public void run() {
        System.out.println(Thread.currentThread().getName() + " finished phase1");
        try {
            cBarrier.await();//执行完阶段1的工作之后，等待其他线程全部执行完阶段1，才会继续执行阶段二
        } catch (InterruptedException e) {
            System.err.println("interrupted!");
        } catch (BrokenBarrierException e) {
            System.err.println("broken barrier!");
        }
        System.out.println(Thread.currentThread().getName() + " start phase2");
        
    }
}

执行结果：

4.可控制并发线程数的信号量Semaphore

使用场景：控制同时访问特定资源的线程数量

package concurrency;

import java.util.concurrent.Semaphore;

public class SemaphoreTest {
    public static void  main(String[] args) {
        final Semaphore semaphore = new Semaphore(3);//限制可以同时访问资源的线程数是10个
        
        for (int i = 0; i < 12; i++) {//新建30个线程
            new Thread(new Runnable() {
                
                @Override
                public void run() {
                    try {
                        semaphore.acquire();//获取到许可证才可以访问资源
                        System.out.println("accessing the database ..");
                        Thread.sleep(3000);
                        semaphore.release();//资源访问结束之后释放许可证
                    } catch (InterruptedException e) {
                        System.out.println("interrupted!");
                    }
                    
                }
            }).start();
        }
        
    }
}