JUC里的同步组件

1.countDownLatch(闭锁)

countDownLatch基于AQS的成员变量state实现的计数器,每次执行countDown()方法时,计数器减1,执行await()方法会阻塞线程直到计数器为0。我的理解 就类似一个大门一样,当计数器为0 大门才会打开,所有的线程才能通过大门,继续执行。一般用在多任务执行,最后汇总(即最终的操作依赖于所有子任务执行完成的结果),所有子任务完成之后,才能进行最终操作,代码示例如下

public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(2);
        ExecutorService executorService = Executors.newFixedThreadPool(2);

        executorService.submit(()->{
                    try {
                        Thread.sleep(10);
                        System.out.println("child threadOne over");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }finally {
                        countDownLatch.countDown();
                    }

        });

        executorService.submit(()-> {
                    try {
                        Thread.sleep(10);
                        System.out.println("child threadTwo over");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }finally {
                        countDownLatch.countDown();//原子操作,同时只能有一个线程操作计数器
                    }

        });

        Thread.sleep(1000);
        System.out.println("wait all child thread over");

        try {
            countDownLatch.await(2, TimeUnit.SECONDS);//调用await()会一直阻塞,直到countDown计数器为0 (大门一直关闭,直到计数器为0打开),并发继续执行
            System.out.println("all child thread over");      //调用await(2, TimeUnit.SECONDS) ,超过这个时间,(大门打开)线程不阻塞,并发继续执行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executorService.shutdown();
    }

2.Cyclicbarrier(回环屏障)

类似于闭锁(也通过计数器实现),每个线程执行完任务之后,执行await()方法,计数器减1,阻塞自己,直到所有线程都执行await()方法,即到达栅栏的位置,栅栏打开,然后可以执行一个所有子线程全部到达屏障后的任务。栅栏之后会被重置,以便于下次使用。(而闭锁是一次性的)。代码示例如下;

 

/**
 * 假设一个任务分三步,每一步让两个线程并发执行,下一步执行的条件是上一步必须执行完。
 */
public class CyclicBarrierDemo2 {
    private static CyclicBarrier cyclicBarrier = new CyclicBarrier(2);
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(2);

        executorService.execute(() -> {
            try {
                System.out.println(Thread.currentThread() + "step1");
                cyclicBarrier.await();

                System.out.println(Thread.currentThread() + "step2");
                cyclicBarrier.await();

                System.out.println(Thread.currentThread() + "step3");
            }catch (Exception e) {

            }
        });

        executorService.execute(() -> {
            try {
                System.out.println(Thread.currentThread() + "step1");
                cyclicBarrier.await();

                System.out.println(Thread.currentThread() + "step2");
                cyclicBarrier.await();

                System.out.println(Thread.currentThread() + "step3");
            }catch (Exception e) {

            }
        });

        executorService.shutdown();
    }
}

 

CyclicBarrier内部维护两个变量parties和count,当count计数值为0,会把parties重新赋值给count,达到重复使用的效果

“如果对await()的调用超时,线程中断,那么栅栏打破,所有阻塞的线程抛异常。如果通过栅栏,那么await()为每个线程返回一个唯一到达索引号,可以利用这些索引号选举出一个领导线程,让他执行特殊的操作”这句话出自《Java并发编程实战》,是基于源码讨论的

总结:countDownLatch简单,只能使用一次,CyclicBarrier可多次使用,还有一个重要的区别是 countDownLatch中子线程执行countDown后,只是告诉了主线程执行完毕,计数器减1,但是子线程还是继续执行的。CyclicBarrier就不同了,子线程执行await()方法后,不会再继续执行,直到所有子线程执行完 打开屏障,子线程才会继续执行

并且有获取阻塞线程数,判断线程是否中断的方法可以使用,还可以初始化时候指定一个所有线程通过栅栏后的任务,执行,代码如下

 final CyclicBarrier  c = new CyclicBarrier(3,()->{
            System.out.println("all thread return");
        });

 

 

3.Semaphore(信号量)

用来控制某个资源可以同时被访问的线程数量,

内部计数器是递增的.把它比作是控制流量的红绿灯,比如XX马路要限制流量,只允许同时有一百辆车在这条路上行使,其他的都必须在路口等待,所以前一百辆车会看到绿灯,可以开进这条马路,后面的车会看到红灯,不能驶入XX马路,但是如果前一百辆中有五辆车已经离开了XX马路,那么后面就允许有5辆车驶入马路,这个例子里说的车就是线程,驶入马路就表示线程在执行,离开马路就表示线程执行完成,看见红灯就表示线程被阻塞,不能执行。可以做流量控制,代码示例如下:

/**
 * 
 * 同时只能有10个线程保存数据
 */
public class SemaphoreDemo3 {
private final static int threadCount = 20;
public static void main(String[] args) {
ExecutorService executorService = Executors.newCachedThreadPool();

//只能有3个线程访问
final Semaphore semaphore = new Semaphore(3);//并发数为3

for (int i = 0; i < threadCount; i++) {
final int threadNum = i ;
executorService.execute(() -> {
try {
semaphore.acquire(); //获取一个许可
test(threadNum); //需要做并发控制的代码,同时只有三个线程可以访问
semaphore.release(); //释放一个许可
}catch (Exception e) {
log.info("exception",e);
}
});
}
executorService.shutdown();
}

private static void test(int threadNum) throws Exception {

log.info("{}",threadNum);
Thread.sleep(1000);
}
 }

 

posted @ 2018-11-25 19:11 雪浪snowWave 阅读(...) 评论(...) 编辑 收藏