面试系列----java并发中常见的辅助类

面试系列----java并发中常见的辅助类

CountDownLatch

让一些线程阻塞直到另外一些完成后才被唤醒的类，CountDownLatch主要有两个方法,当一个或多个线程调用await方法时,调用线程会被阻塞.其他线程调用countDown方法计数器减1(调用countDown方法时线程不会阻塞),当计数器的值变为0,因调用await方法被阻塞的线程会被唤醒，继续执行。

简单代码演示：

public class CountDownLatchDemo {

    public static void main(String[] args) {

        CountDownLatch countDownLatch = new CountDownLatch(7);

        for (int i = 0; i < 7; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "\t" + "离开");
                countDownLatch.countDown();

            },String.valueOf(i)).start();
        }

        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName()+"\t关门");


    }
}

CyclicBarrier

CyclicBarrier的字面意思是可循环(Cyclic) 使用的屏障(barrier).它要做的事情是,让一组线程到达一个屏障(也可以叫做同步点)时被阻塞,知道最后一个线程到达屏障时,屏障才会开门,所有被屏障拦截的线程才会继续干活,线程进入屏障通过CyclicBarrier的await()方法。

简单代码展示当写入数据库的必须多个线程完成写操作以后才可进行后续的操作：

public class CyclicBarrierDemo {


    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,() ->{
            System.out.println("写线程已经结束,进行下面操作");
        });


        for (int i = 0; i < 7; i++) {
            new Thread(() ->{

                System.out.println(Thread.currentThread().getName()+"\t写操作正在进行中...");

                try {
                    cyclicBarrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }

    }
}

而相比于CountDownlatch这个类，CyclicBarrier可以循环使用，可以重用同时使用多次，而CountDownLatch当减到0为止就不能使用了。

Semaphore

信号量的主要用户两个目的，一个是用于多个共享资源的相互排斥使用，另一个用于并发资源数的控制。

用生活中的例子说，就是停车场有3个车位，有6量车进入停车场，然后通过信号量的控制，可以使得停车顺利进行。

代码展示：

public class SemaphoreDemo {

    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);

        for (int i = 0; i < 6; i++) {
            new Thread(() ->{
                try {
                    semaphore.acquire();

                    System.out.println(Thread.currentThread().getName()+"\t停车");

                    try {
                        TimeUnit.SECONDS.sleep(3);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName()+"\t停3秒钟离开");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release();
                }

            },String.valueOf(i)).start();
        }
    }

}

参考：

Java并发编程：CountDownLatch、CyclicBarrier和Semaphore