java常用并发编程 CountDownLatch、CyclicBarrier、Semaphore

CountDownLatch

倒计时闩，主要用于等待所以子任务完成后，才能开始完成的任务，依赖顺序问题

CyclicBarrier

循环路障，可以理解为赛马的围栏，每次reset后就一起出来执行任务，适合需要同时执行的任务

Semaphore

信号量，共享资源管理，多线程资源共享处理

简单代码说明使用过程，方便理解

import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.Semaphore;

public class Test {

    public static void main(String[] args) {

        // example for CountDownLatch
        final CountDownLatch workCount=new CountDownLatch(2);
        for(int i=0;i<2;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    int i = new Random().nextInt(1000);
                    try {
                        Thread.sleep(i);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("work done:"+i);
                    workCount.countDown();
                }
            }).start();
        }

        try {
            workCount.await();
            System.out.println("waiting workCount end!");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // example for CyclicBarrier
        System.out.println();
        CyclicBarrier barrier = new CyclicBarrier(2);
        for(int i=0;i<2;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    int i = new Random().nextInt(1000);
                    try {
                        barrier.await();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }

                    System.out.println("start to work :"+i);

                }
            }).start();
        }
        // make thread start to work
        barrier.reset();


        // example for Semaphore
        System.out.println();
        Semaphore machine = new Semaphore(2);
        for(int i=0;i<5;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    int i = new Random().nextInt(1000);
                    try {
                        machine.acquire();
                        System.out.println("machine ["+machine.toString()+"]to do work:"+i);
                        machine.release();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }

                }
            }).start();
        }
    }
}