java并发编程之CountDownLatch,CyclicBarrier,Semaphore的简单应用

前言

这三个类都是在java1.5的时候由Doug Lea大神添加于java.util.concurrent,这三个辅助类都基于AQS同步器框架实现,下面我们简单介绍下它们的简单使用

CountDownLatch

CountDownLatch类似是一个计数器,他可以实现需要所有任务都执行完毕才可以执行接下来的任务,日常场景中我们可以使用他来做并行分布运算,借用多核cpu对数据分别进行计算,然后再汇总,也可以实现在加载某些东西前初始化一些信息。

主要方法

public CountDownLatch(int count);//构造函数
public void countDown();//计数器-1
public void await() throws InterruptedException;//挂起
public boolean await(long timeout, TimeUnit unit);//与await()类似,这里可以指定时间,达到时间如果计数器没归0也可以执行下面的东西

简单例子

private static void countDownLatchApply() throws Exception {
        //初始化2个
        CountDownLatch countDownLatch = new CountDownLatch(2);
        new Thread(() -> {
            try {
                System.out.println("我是线程" + Thread.currentThread().getName() + "我执行在"
                        +LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss")));
                //模拟处理耗时
                Thread.sleep(2000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                countDownLatch.countDown();
            }
        }).start();

        new Thread(() -> {
            try {
                System.out.println("我是线程" + Thread.currentThread().getName() + "我执行在"+
                        LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss")));
                //模拟处理耗时
                Thread.sleep(2000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                countDownLatch.countDown();
            }
        }).start();


        countDownLatch.await();

        new Thread(() -> {
            System.out.println("我是线程" + Thread.currentThread().getName() + "我需要前面两个执行完我才可以执行,我执行在"+
                    LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss")));
        }).start();

    }

执行结果

我是线程Thread-1我执行在2019/05/15 08:05:36
我是线程Thread-0我执行在2019/05/15 08:05:36
我是线程Thread-2我需要前面两个执行完我才可以执行,我执行在2019/05/15 08:05:38

我们会看到线程2是需要在线程0和1执行玩后再执行的,我特意让线程休眠了2秒,后面的时间也印证了线程2是在线程0和线程1后2秒执行的

CyclicBarrier

回环栅栏,他可以使线程全部到达一个同步点后,再一起执行下面的动作,他是可重用的,等线程到达同步点,这个线程是可以被做其他使用的,我们姑且叫这个状态为可重用态,当调用await(),线程就为可重用态

主要方法

public CyclicBarrier(int parties);//构造方法
public CyclicBarrier(int parties, Runnable barrierAction);//构造方法,可实现更复杂的动作
public int await() throws InterruptedException, BrokenBarrierException;//挂起
public int await(long timeout, TimeUnit unit);//带时间,到期可执行下面操作

简单例子

 private static void cyclicBarrierApply() {

        CyclicBarrier cyclicBarrier=new CyclicBarrier(4, new Runnable() {
            @Override
            public void run() {
                System.out.println("我是线程"+Thread.currentThread().getName()+",老板,我按照你的要求在他们向你汇报前检查了他们4个的工作,他们一会会亲自向你汇报");
            }
        });

        for (int i = 0; i <4 ; i++) {
            new Thread(() ->{
                try {
                    Thread.sleep(2000L);
                    System.out.println("我是线程"+Thread.currentThread().getName()+",我的工作做完了,等其他线程工作好"
                    +",我们一起去向老板汇报");
                    cyclicBarrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("老板,我来向你汇报工作了");
                }

            }).start();
        }

    }

执行结果

我是线程Thread-0,我的工作做完了,等其他线程工作好,我们一起去向老板汇报
我是线程Thread-1,我的工作做完了,等其他线程工作好,我们一起去向老板汇报
我是线程Thread-3,我的工作做完了,等其他线程工作好,我们一起去向老板汇报
我是线程Thread-2,我的工作做完了,等其他线程工作好,我们一起去向老板汇报
我是线程Thread-2,老板,我按照你的要求在他们向你汇报前检查了他们4个的工作,他们一会会亲自向你汇报
我是线程Thread-2老板,我来向你汇报工作了
我是线程Thread-3老板,我来向你汇报工作了
我是线程Thread-1老板,我来向你汇报工作了
我是线程Thread-0老板,我来向你汇报工作了

我们可以看到所有线程最开始都在完成自己的工作,并等待其他线程一起向“老板”汇报,线程完成工作了,变为了可重用态,这个时候线程2被重用,他被“老板”安排在四个线程汇报工作前先检查他们的工作,也就是第二个构造方法的运用,最后四个线程一起去向“老板”汇报工作。

CountDownLatch与CyclicBarrier的比较

他们的功能有一些类似,CountDownLatch是所有线程都到达一个点才能执行下面的动作,而CyclicBarrier是所有线程都到达一个点再一起执行下面的动作,CountDownLatch不可被重用,CyclicBarrier可以被重用

Semaphore

信号量,它可用于对资源进行有效的控制,获取到许可就可以使用,使用完许可主动释放掉,获取不到就需要等到有许可可以使用

主要方法

public Semaphore(int permits) //参数表示许可数目,同时可以允许多少线程进行访问
public Semaphore(int permits, boolean fair)  //fair表示是否是公平的,等待时间越久的越先获得许可
public void acquire() throws InterruptedException ;    //获取一个许可 会造成阻塞
public void acquire(int permits) throws InterruptedException ;    //获取permits个许可 会造成阻塞
public void release() ;        //释放一个许可 会造成阻塞
public void release(int permits) ;   //释放permits个许可 会造成阻塞
//下面四个方法与上面的一样,但是下面会立即获得结果,不会阻塞,操作失败就返回false
public boolean tryAcquire();
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException
public boolean tryAcquire(int permits)
public boolean tryAcquire(int permits, long timeout, TimeUnit unit)

简单例子

private static void semaphoreApply() throws Exception {
        //仓库管理员
        Semaphore semaphore = new Semaphore(4);
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    //向仓库管理员要一把钥匙
                    semaphore.acquire();
                    System.out.println("我是线程" + Thread.currentThread().getName() + "我成功申请到了一把钥匙");
                    Thread.sleep(3000L);
                    System.out.println("我是线程" + Thread.currentThread().getName() + "我使用好了钥匙");
                    //给管理员说我用好了
                    semaphore.release();
                    System.out.println("我是线程" + Thread.currentThread().getName() + "我已经将钥匙还回去了");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }

    }

运行结果

我是线程Thread-0我成功申请到了一把钥匙
我是线程Thread-2我成功申请到了一把钥匙
我是线程Thread-1我成功申请到了一把钥匙
我是线程Thread-3我成功申请到了一把钥匙
我是线程Thread-2我使用好了钥匙
我是线程Thread-1我使用好了钥匙
我是线程Thread-4我成功申请到了一把钥匙
我是线程Thread-6我成功申请到了一把钥匙
我是线程Thread-0我使用好了钥匙
我是线程Thread-2我已经将钥匙还回去了
我是线程Thread-1我已经将钥匙还回去了
我是线程Thread-5我成功申请到了一把钥匙
我是线程Thread-0我已经将钥匙还回去了
我是线程Thread-3我使用好了钥匙
我是线程Thread-3我已经将钥匙还回去了
我是线程Thread-7我成功申请到了一把钥匙
我是线程Thread-5我使用好了钥匙
我是线程Thread-5我已经将钥匙还回去了
我是线程Thread-6我使用好了钥匙
我是线程Thread-7我使用好了钥匙
我是线程Thread-9我成功申请到了一把钥匙
我是线程Thread-4我使用好了钥匙
我是线程Thread-7我已经将钥匙还回去了
我是线程Thread-6我已经将钥匙还回去了
我是线程Thread-8我成功申请到了一把钥匙
我是线程Thread-4我已经将钥匙还回去了
我是线程Thread-9我使用好了钥匙
我是线程Thread-9我已经将钥匙还回去了
我是线程Thread-8我使用好了钥匙
我是线程Thread-8我已经将钥匙还回去了

我们可以看到,最开始只有4个获取到了许可,我在这里将线程休眠3秒,模拟耗时,在这期间没有其他线程获取到许可,并且同时也只能有四个在运行,每下一个获取到许可都必须是有线程释放许可,

参考资料:《java编程思想》

你可能感兴趣的:(java并发编程之CountDownLatch,CyclicBarrier,Semaphore的简单应用)