java并发工具类CountDownLatch、CyclicBarrier 、Semaphore 和 Exchanger

CountDownLatch、CyclicBarrier 、Semaphore 和 Exchanger 工具类提供了一种并发流程控制的手段

等待多线程完成的 CountDownLatch

示例一:join方式，join 用于让当前执行线程等待 join 线程执行结束。

public class JoinTest {
	 public static void main(String[] args) throws InterruptedException {
		 Thread parser1 = new Thread(new Runnable() {
		 @Override
		 	public void run() {
		 }
	 });
	 Thread parser2 = new Thread(new Runnable() {
		 @Override
		 public void run() {
			 System.out.println("parser2 finish");
		 }
	 });
	 parser1.start();
	 parser2.start();
	 parser1.join();
	 parser2.join();
	 System.out.println("all parser finish");
	 }
}

示例二：CountDownLatch

public class CountDownLatchTest {
	//如果你想等待 N个点完成，这里就传入 N。
    static CountDownLatch c = new CountDownLatch(2);

    public static void main(String[] args) throws InterruptedException {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(1);
                // 调用countDown方法N值就-1
                c.countDown();
                System.out.println(2);
                c.countDown();
            }
        }).start();
        c.await();
        System.out.println(3);
    }

}

同步屏障 CyclicBarrier

让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行。

public class CyclicBarrierTest {
	// 等待到达屏障的线程的个数N
    static CyclicBarrier c = new CyclicBarrier(2);

    public static void main(String[] args) throws BrokenBarrierException, InterruptedException {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                	// N--
                    c.await();
                } catch (Exception e) {
                }
                System.out.println(1);
            }
        }).start();
        // N--
        c.await();
        System.out.println(2);
    }
}

因为主线程和子线程的调度是由 CPU 决定的，两个线程都有可能先执行
所以输出结果可能为 1 2 ，也可能为2 1

控制并发线程数的 Semaphore

假如有一个需求，要读取几万个文件的数据，因为都是 IO 密集型任务，我们可以启动几十个线程并发地读取，但是如果读到内存后，还需要存储到数据库中，而数据库的连接数只有 10 个，这时我们必须控制只有 10 个线程同时获取数据库连接保存数据，否则会报错无法获取数据库连接。这个时候，就可以使用Semaphore 来做流量控制

public class SemaphoreTest {
	 private static final int THREAD_COUNT = 30;
	 private static ExecutorService threadPool = 
		Executors.newFixedThreadPool(THREAD_COUNT);
	 private static Semaphore s = new Semaphore(10);
	 public static void main(String[] args) {
		 for (int i = 0; i < THREAD_COUNT; i++) {
			 threadPool.execute(new Runnable() {
			 @Override
			public void run() {
				 try {
					 s.acquire();
					System.out.println("save data");
					 s.release();
					 } catch (InterruptedException e) {
				 }
			 }
		 });
		 }
	 threadPool.shutdown();
	 }
}

线程间交换数据的 Exchanger

实现两个线程之间交换数据，通过B线程执行exchange方法获取A线程的数，前提是A线程调用了exchange方法并把数据传入

public class ExchangeTest {
    private static final Exchanger<String> excg = new Exchanger<>();
    private static ExecutorService threadPool = Executors.newFixedThreadPool(2);

    public static void main(String[] args) {
        threadPool.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    String A = "A数据 录入交换系统";
                    //获取到B,并传入A
                    String B = excg.exchange(A);
                    System.out.println("A线程取到的结果: "+B);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        threadPool.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    String B = "B数据 录入交换系统";
                    // 获取到A,并传入B
                    String A = excg.exchange(B);
                    System.out.printf("A 和 B 数据是否一致：" + A.equals(B) + "，A 录入的是："
                            + A + "，B 录入是：" + B);
                } catch (InterruptedException e) {


                }
            }
        });
        threadPool.shutdown();

    }
}

必须两个线程都调用exchange方法，否则一个线程一直等待，可以使用 exchange（V x，longtimeout，TimeUnit unit）设置最大等待时长。