CountDownLatch(闭锁)

什么是CountDownLatch

CountDownLatch是一个同步工具类, 用来协调多个线程之间的同步, 或者说起到线程之间的通信(而不是用作互斥的作用)。

CountDownLatch能够使一个线程在等待另外一些线程完成各自工作之后, 再继续执行。使用一个计数器进行实现。计数器初始值为线程的数量。当每一个线程完成自己任务后, 计数器的值就会减一, 当计数器的值为0时, 表示所有的线程都已经完成一些任务, 然后在CountDownLatch上等待的线程就可以恢复执行接下来的任务。

CountDownLatch的用法

• 当一个或多个线程调用await方法时, 这些线程会阻塞
• 其它线程调用countDown方法会将计数器减1(调用countDown方法的线程不会阻塞)
• 计数器的值变为0时, 因await方法阻塞的线程会被唤醒, 继续执行

案例: 秦始皇灭掉六国, 一统天下

//使用枚举类创建六个国家
enum CountryEnum {
    one(1, "齐"), two(2, "楚"), three(3, "燕"),
    four(4, "赵"), five(5, "魏"), six(6, "韩");
    private Integer retCode;
    private String retMessage;
    private CountryEnum(Integer retCode, String retMessage) {
        this.retCode = retCode;
        this.retMessage = retMessage;
    }
    public static CountryEnum getCountryEnum(Integer index) {
        CountryEnum[] countryEnums = CountryEnum.values();
        for (CountryEnum countryEnum : countryEnums) {
            if (countryEnum.getRetCode().equals(index)) {
                return countryEnum;
            }
        }
        return null;
    }
    public Integer getRetCode() {
        return retCode;
    }
    public String getRetMessage() {
        return retMessage;
    }
}
public class CountDownLatchDemo {
    public static void main(String[] args) throws Exception {
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 1; i <= 6; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "国, 被灭");
                countDownLatch.countDown();
            }, CountryEnum.getCountryEnum(i).getRetMessage()).start();

        }
        countDownLatch.await();
        System.out.println(Thread.currentThread().getName() + "\t" + "秦国一统天下");
    }
}

运行结果:

额, 好像没有按照历史顺序来, 不过无伤大雅

CountDownLatch的不足

CountDownLatch是一次性的, 计数器的值只能在构造方法中初始化一次, 之后没有任何机制再次对其设置值, 当CountDownLatch使用完毕后, 它不能再次被使用。

CyclicBarrier(循环栅栏)

CyclicBarrier是什么

CyclicBarrier是一个同步辅助类, 它允许一组线程相互等待直到所有线程都到达一个公共的屏障点。
在程序中有固定数量的线程, 这些线程有时候必须等待彼此, 意思就是每个线程都得执行到等待点进行等待, 直到所有线程都执行到等待点, 才会继续往下执行。这种情况下, 使用CyclicBarrier很有帮助。这个屏障之所以用循环修饰, 是因为在所有的线程释放彼此之后, 这个屏障是可以重新使用的。

CyclicBarrier的用法

构造方法:

• CyclicBarrier(int parties), 当等待线程数量达到parties时, 放行所有线程

• CyclicBarrier(int parties，Runnable barrierAction), 当等待线程数量达到parties时, 放行所有线程, 并由最后一个线程执行barrierAction

案例: 收集七龙珠召唤神龙

public class CyclicBarrierDemo {
    //创建固定值
    private static final int NUMBER = 7;

    public static void main(String[] args) {
        //创建CyclicBarrier
        CyclicBarrier cyclicBarrier = new CyclicBarrier(NUMBER, () -> {
            System.out.println("召唤神龙");
        });

        for (int i = 1; i <= 7; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "星龙珠");
                //等待
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }, "" + i).start();
        }
    }
}

运行结果:

CyclicBarrier与CountDownLatch的区别

• CyclicBarrier是对计数器做加法
• CountDownLatch是对计数器做减法
• CountdownLatch是一次性的
• CycliBarrier是可以重复使用的, 使用reset()方法即可重置计数器

Semaphore(信号灯)

Semaphore是什么

Semaphore是计数信号量。Semaphore管理一系列许可。每个acquire方法阻塞, 直到有一个许可证可以获得然后拿走一个许可证；每个release方法增加一个许可, 这可能会释放一个阻塞的acquire方法。然而, 其实并没有实际的许可这个对象, Semaphore只是维持了一个可获得许可证的数量。

Semaphore的用法

• acquire(获取)当一个线程调用acquire操作时, 它要么通过成功获取信号量(信号量减1), 要么一直等下去, 直到有线程释放信号量, 或超时。
• release(释放)实际上会将信号量的值加1, 然后唤醒等待的线程。
• 信号量主要用于两个目的, 一个是用于多个共享资源的互斥使用, 另一个用于并发线程数的控制。

案例: 停车场抢车位

public class SemaphoreDemo {

    public static void main(String[] args) {
        //创建Semaphore, 设置许可量, 模拟三个车位
        Semaphore semaphore = new Semaphore(3);

        //模拟六辆汽车
        for (int i = 1; i <= 6; i++) {
            new Thread(()->{
                try {
                    //获取许可
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "号车抢到车位");
                    //设置随机停车时间
                    TimeUnit.SECONDS.sleep(new Random().nextInt(5));
                    System.out.println(Thread.currentThread().getName() + "号车离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    //释放许可
                    semaphore.release();
                }
            }, "" + i).start();
        }
    }
}

运行结果:

可以看到, 如果有三个线程得到了许可, 那么剩下的线程就会被阻塞, 知道有线程释放许可, 才会随机释放一个被阻塞的线程获得许可。

我的个人主页: www.ayu.link
本文连接: ┏ (゜ω゜)=☞