JUC下的常见类

JUC（ java.util.concurrent）:

1. ReentrantLock

a. lock写在try之前；
b.一定要在finaly里面进行unlock();

2. 信号量（Semaphore）：

（一个计数信号量，主要用于控制多线程对共同资源库访问的限制）

该类用于控制信号量的个数，构造时传入个数。总数就是控制并发的数量。假如是 5，程序执 行前用 acquire()方法获得信号，则可用信号变为 4，程序执行完通过 release()方法归还信号量，可用 信号又变为 5.如果可用信号为 0，acquire 就会造成阻塞，等待 release 释放信号。acquire 和 release 方法可以不在同一个线程使用。Semaphore 实现的功能就类似厕所有 5 个坑，假如有 10 个人要上厕 所，那么同时只能有多少个人去上厕所呢？同时只能有 5 个人能够占用，当 5 个人中 的任何一个人 让开后，其中等待的另外 5 个人中又有一个人可以占用了。另外等待的 5 个人中可以是随机获得优先机会，也可以是按照先来后到的顺序获得机会，这取决于构造 Semaphore 对象时传入的参数选项。
单个信号量的 Semaphore 对象可以实现互斥锁的功能，并且可以是由一个线程获得了“锁”，再由另 一个线程释放“锁”，这可应用于死锁恢复的一些场合。

import java.util.Random;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.Semaphore;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 信号量演示程序（停车场）
 */
public class ThreadDemo98 {
    public static void main(String[] args) {
        // 创建信号量
        Semaphore semaphore = new Semaphore(2, true);

        ThreadPoolExecutor executor = new ThreadPoolExecutor(10, 10,
                0, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(100));
        for (int i = 0; i < 4; i++) {
            // 创建任务
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() +
                            " 到达停车场");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    try {
                        // 尝试获取锁
                        semaphore.acquire();
                        // 当代码执行到此处说明已经获取到锁
                        System.out.println(Thread.currentThread().getName() +
                                " 进入停车场---------");
                        // 车辆停留的时间构建
                        int num = 1 + new Random().nextInt(5);
                        try {
                            Thread.sleep(num * 1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        // 离开停车场
                        System.out.println(Thread.currentThread().getName() +
                                " 离开停车场！！！！！");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        // 释放锁
                        semaphore.release();
                    }
                }
            });
        }
    }
}

3. 计数器（CountDownLatch）：

（计数器是用来保证一组线程同时完成某个操作之后，才能继续后面的任务。）

这个类是一个同步计数器，主要用于线程间的控制，当 CountDownLatch 的 count 计数>0 时， await()会造成阻塞，直到 count 变为 0，await()结束阻塞，使用 countDown()会让 count 减 1。 CountDownLatch 的构造函数可以设置 count 值当 count=1 时，它的作用类似于 wait()和 notify() 的作用。如果我想让其他线程执行完指定程序，其他所有程序都执行结束后我再执行，这时可以CountDownLatch，但计数无法被重置，如果需要重置计数，请考虑使用 CyclicBarrier 。

利用它可以实现类似计数器的功能。比如有一个任务 A，它要等待其他 4 个任务执行完毕之后才能执行，此时就可以利用CountDownLatch来实现这种功能了。

await()方法： 当线程数不满足CountDownLatch的数量的时候，执行此代码会阻塞等待，直到数量满足之后，再执行await 之后的代码。

面试题：CountDownLatch是如何实现的？

答:在CountDownLatch 里面有一个计数器，每次调用countDown()方法的时候计数器的数量-1，直到减到0之后，就可以执行await之后的代码了。

CountDownLatch的使用：

CountDownLatch缺点：

计数器的使用是一次性的，当使用完之后就不在使用了（这时可以考虑 CyclicBarrier）。

import java.util.concurrent.CountDownLatch;

/**
 * 计数器示例
 */
public class ThreadDemo99 {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(5);
        for (int i = 1; i < 6; i++) {
            final int finalI = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() +
                            " 开始起跑");
                    try {
                        Thread.sleep(finalI * 200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() +
                            " 到达终点");
                    // 将计数器 -1
                    latch.countDown();
                }
            }).start();
        }
        // 阻塞等待
        latch.await();
        System.out.println("所有人都到达终点了，公布排名");
    }
}

4. 循环栅栏（CyclicBarrier）：

字面意思回环栅栏，通过它可以实现让一组线程等待至某个状态之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后，CyclicBarrier可以被重用。我们暂且把这个状态就叫做barrier，当调用 await()方法之后，线程就处于 barrier了。和之前的 CountDownLatch 相比，它只有 await 方法，而 CountDownLatch 是使用 countDown()方法将计数器减到 0，它创建的参数就是 countDown 的数量；CyclicBarrier 创建时的 int 参数是 await 的数量。

面试题：CycilcBarrier 和 CountDownLatch区别？

CountDownLatch的计数器只能使用一次，CycilcBarrier的计数器可以重复使用。

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/**
 * 循环屏障示例
 */
public class ThreadDemo100 {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(5, new Runnable() {
            @Override
            public void run() {
                System.out.println("执行了 CyclicBarrier 里面的 Runnable");
            }
        });

        for (int i = 1; i < 11; i++) {
            int finalI = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()
                            + " 开始起跑");
                    try {
                        Thread.sleep(finalI * 200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    try {
                        System.out.println(Thread.currentThread().getName()
                                + " 等待其他人---------");
                        // 计数器 -1，判断计时器是否为 0
                        cyclicBarrier.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                    // 代码执行带此行，说明已经有一组线程已经满足条件了
                    System.out.println(Thread.currentThread().getName()
                            + " 执行结束！！！！！");
                }
            }).start();
        }
    }
}