多线程之Callable接口、ReentrantLock、信号量 Semaphore以及CountDownLatch

目录：

一、Callable接口

Callable的用法

小结

二、ReentrantLock

ReentrantLock 的用法

ReentrantLock 和 synchronized 的区别？

为什么有了 synchronized 还需要 juc(java.util.concurrent) 下的 lock？

三、信号量 Semaphore

如何理解信号量？

信号量可以用在过哪些场景下？

线程同步的方式有哪些？

四、CountDownLatch

---

一、Callable接口

Callable的用法

Callable 是一个 interface，相当于把线程封装了一个 "返回值"，方便借助多线程的方式计算结果。

代码示例: 创建线程计算 1 + 2 + 3 + ... + 1000, 使用 Callable 版本

  public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 1; i <= 1000; i++) {
                    sum += i;
                }
                return sum;
            }
        };

        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread t = new Thread(futureTask);
        t.start();
        int ret = futureTask.get();
        System.out.println(ret);
    }

1.创建一个匿名内部类, 实现 Callable 接口，Callable 带有泛型参数，泛型参数表示返回值的类型。

2.重写 Callable 的 call 方法, 完成累加的过程，直接通过返回值返回计算结果。

3.把 callable 实例使用 FutureTask 包装一下。

4.创建线程, 线程的构造方法传入 FutureTask ，此时新线程就会执行 FutureTask 内部的 Callable 的

call 方法, 完成计算，计算结果就放到了 FutureTask 对象中。

5.在主线程中调用 futureTask.get() 能够阻塞等待新线程计算完毕，并获取到 FutureTask 中的结

果。

小结

Callable 和 Runnable 都是描述一个 "任务"，Callable 描述的是带有返回值的任务,Runnable 描述的是不带返回值的任务。

Callable 通常需要搭配 FutureTask 来使用，FutureTask 用来保存 Callable 的返回结果，因为Callable 往往是在另一个线程中执行的, 啥时候执行完并不确定，FutureTask 就可以负责这个等待结果出来的工作。

二、ReentrantLock

ReentrantLock 的用法

ReentrantLock是可重入的，和 synchronized类似, 保证线程安全。

ReentrantLock 的用法:

lock(): 加锁, 如果获取不到锁就死等

trylock(超时时间): 加锁, 如果获取不到锁, 等待一定的时间之后就放弃加锁

unlock(): 解锁

伪代码：

ReentrantLock lock = new ReentrantLock();
lock.lock();
try {
   // 业务逻辑
} finally {
   lock.unlock()
}

ReentrantLock 和 synchronized 的区别？（为什么有了 synchronized 还需要 juc(java.util.concurrent) 下的 lock？）

1.synchronized 是一个关键字, 是 JVM 内部实现的(可能是基于 C++ 实现的)，ReentrantLock 是标准库的一个类, 在 JVM 外实现的(基于 Java 实现)。

2.synchronized 使用时不需要手动释放锁，ReentrantLock 使用时需要手动释放，ReentrantLock使用起来更灵活,但是也容易遗漏 unlock。

3.synchronized 在申请锁失败时, 会死等，ReentrantLock 可以通过 trylock 的方式等待一段时间就放弃。

4.synchronized 是非公平锁, ReentrantLock 默认是非公平锁，但是可以通过构造方法传入一个 true 开启公平锁模式。

5.ReentrantLock 有更强大的唤醒机制。synchronized 是通过 Object 的 wait / notify 实现等待-唤醒，每次唤醒的是一

个随机等待的线程。而ReentrantLock 搭配 Condition 类实现等待-唤醒, 可以更精确控制唤醒某个指定的线程。

如何选择使用哪个锁?

在锁竞争不激烈的时候, 使用 synchronized, 效率更高, 自动释放更方便。

在锁竞争激烈的时候, 使用 ReentrantLock, 搭配 trylock 更灵活控制加锁的行为, 而不是死等。

如果需要使用公平锁, 使用 ReentrantLock。

三、信号量 Semaphore

如何理解信号量？

信号量用来表示 "可用资源的个数"，其本质上就是一个计数器。Semaphore 的 PV 操作中的加减计数器操作都是原子的, 可以在多线程环境下直接使用。

代码示例：

1.创建 Semaphore 示例, 初始化为 4, 表示有 4 个可用资源

2.acquire 方法表示申请资源(P操作), release 方法表示释放资源(V操作)

3.创建 20 个线程, 每个线程都尝试申请资源, sleep 1秒之后, 释放资源

观察程序的执行效果：当申请到4个资源后，就会进行线程等待，等待资源的释放。

public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(4);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("申请资源");
                    semaphore.acquire();
                    System.out.println("我获取到资源了");
                    Thread.sleep(1000);
                    System.out.println("我释放资源了");
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        for (int i = 0; i < 20; i++) {
            Thread t = new Thread(runnable);
            t.start();
        }
    }

信号量可以用在过哪些场景下？

信号量是用来表示 "可用资源的个数"，其本质上就是一个计数器。使用信号量可以实现 "共享锁", 比如某个资源允许 3 个线程同时使用, 那么就可以使用 P 操作（acquire 方法）作为加锁, V 操作（release 方法）作为解锁, 前三个线程的 P 操作都能顺利返回, 后续线程再进行 P 操作就会阻塞等待,直到前面的线程执行了 V 操作。

线程同步的方式有哪些？

synchronized, ReentrantLock, Semaphore 等都可以用于线程同步。

四、CountDownLatch

CountDownLatch是同时等待 N 个任务执行结束。

代码示例：

1.构造 CountDownLatch 实例, 初始化 10 表示有 10 个任务需要完成

2.每个任务执行完毕, 都调用 latch.countDown()，在 CountDownLatch 内部的计数器同时自减

3.主线程中使用 latch.await()， 阻塞等待所有任务执行完毕，相当于计数器为 0 了

 public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(10);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep((long) (Math.random()*10000));
                    latch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        for (int i = 0; i < 10; i++) {
            new Thread(runnable).start();
        }
        latch.await();
        System.out.println("10个任务全部结束");
    }