【Java多线程】面试常考 —— JUC(java.util.concurrent) 的常见类

1、JUC（java.util.concurrent）

[1.1、Callable 接口](#1.1、Callable 接口)

[1.2、ReentrantLock 可重入锁](#1.2、ReentrantLock 可重入锁)

[1.3、Semaphore 信号量](#1.3、Semaphore 信号量)

1.4、CountDownLatch

1、JUC（java.util.concurrent）

这是java中的一个包，存放着多线程编程中常见的一些类。

1.1、Callable 接口

【Java多线程】Thread类的基本用法-CSDN博客https://blog.csdn.net/zzzzzhxxx/article/details/136121421?spm=1001.2014.3001.5501

往期的博客中对创建线程的几种方式进行过说明，有如下几种：

1、继承 Thread（包含了匿名内部类的方式）

2、实现 Runnable（包含了匿名内部类的方式）

3、基于 lambda 表达式

其实除了以上方式，还有一个方式可以创建线程，即基于 Callable 的创建方法。

java 复制代码

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

        //引入 FutureTask 类，作为 Thread 和 callable 的 "粘合剂"
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread t = new Thread(futureTask);
        t.start();

        //取餐号，使用 futureTask 获取到结果，具有阻塞功能
        System.out.println(futureTask.get());
    }

基于 Callable 同样可以创建线程，那么它与 Runnable 有什么区别呢？

Runnable 关注的是整个过程，不关注执行结果，Runnable 提供的是 run 方法，返回值类型是 void。

Callable 关注的是执行结果，Callable 提供的是 call 方法，返回值就是线程执行任务得到的结果。

因此，如果编写多线程代码时，希望关注线程中代码的返回值时，此时使用基于 Callable 实现的线程更为方便。

1.2、ReentrantLock 可重入锁

与 synchronized 有区别，上古时期的 Java，synchronized 还不够强壮，功能也不够强大，也没有各种优化，当时 ReenactmentLock 就是实现可重入锁的选择。

ReenactmentLock 的用法具有传统锁的风格，上锁使用lock()，解锁使用unlock()。

由于需要手动解锁，触发 return 或者异常时容易忘记解锁，为了避免这种问题，正确使用 ReenactmentLock 时需要把 unlock 操作放到 finally 中。

问题：既然有 synchronized，为啥还要用 ReenactmentLock ？（面试题）

1、ReenactmentLock 提供了 tryLock 操作。

lock 尝试进行加锁，如果加锁不成，就会阻塞；

tryLock 尝试进行加锁，如果加锁不成，不阻塞，直接返回 false；（更多的可操作空间）

2、ReenactmentLock 提供了公平锁的实现，通过队列记录加锁线程的先后顺序。

3、搭配的等待通知机制不同。

对于 synchronized，搭配 wait/notify

对于 ReenactmentLock，搭配 Condition 类，功能比 wait/notify 略强一些

1.3、Semaphore 信号量

首先举例说明 semaphore 信息量的概念：停车场入口立着的那个显示屏，每有一辆车进入停车场显示屏就会显示剩余车位减1，每有一辆车从停车场出去，显示屏上显示的剩余车辆就会加1，当显示屏上的剩余车位为0时，停车场入口的栏杆就不会再打开，车辆就无法进入停车场了，直到有一辆车从停车场出去为止。

而这个场景中提及的"显示屏"这个东西，就可以认为是信息量，表示"可用资源的个数"，申请一个可用资源，就会使数字 - 1，这个操作就成为 p 操作，释放一个可用资源，就会使数字 + 1，这个操作就是 v 操作，如果信息量数值为 0，继续 p 操作就会进行阻塞。

信号量是更广义的"锁"。所谓锁，本质上也是一种特殊的信息量，可以把锁认为是计数值为 1 的信息量。释放状态，就是1，加锁状态就是0，对于这种非0即1的信息量，称为"二元信息量"。除此之外，同样 Semaphore 也可以用来实现生产者消费者模型。

acquire() 表示申请资源(P操作)；
release() 表示释放资源(V操作)；

使用 semaphore 模式锁并使用模拟锁实现两个线程同时对 i 自增 5 w 的操作

java 复制代码

package thread;

import java.util.concurrent.Semaphore;

public class ThreadDemo38 {
    private static int count = 0;

    public static void main(String[] args) throws InterruptedException {
        //信息量设置为 1
        Semaphore semaphore = new Semaphore(1);

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                try {
                    semaphore.acquire();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                count++;
                semaphore.release();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                try {
                    semaphore.acquire();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                count++;
                semaphore.release();
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println("count = " + count);
    }
}

1.4、CountDownLatch

针对特定场景下解决问题的小工具。作用：同时等待 N 个任务执行结束。

比如，多线程执行一个任务，把大的任务拆分成几个部分，由每个线程分别执行。"多线程下载"：idm，比特彗星。

java 复制代码

package thread;

import java.util.Random;
import java.util.concurrent.CountDownLatch;

public class ThreadDemo39 {
    public static void main(String[] args) throws InterruptedException {
        // 1. 此处构造方法中写 10, 意思是有 10 个线程/任务
        CountDownLatch latch = new CountDownLatch(10);

        // 创建出 10 个线程负责下载.
        for (int i = 0; i < 10; i++) {
            int id = i;
            Thread t = new Thread(() -> {
                Random random = new Random();
                // [0, 5)
                int time = (random.nextInt(5) + 1) * 1000;
                System.out.println("线程 " + id + " 开始下载");
                try {
                    Thread.sleep(time);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("线程 " + id + " 结束下载");
                // 2. 告知 countDownLatch 我执行结束了.
                latch.countDown();
            });
            t.start();
        }

        // 3. 通过这个 await 操作来【等待所有任务结束】. 也就是 countDown 被调用 10 次了.
        latch.await();
        System.out.println("所有任务都已经完成了!");
    }
}

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

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

如果觉得作者写的不错，求给博主一个大大的点赞支持一下，你们的支持是我更新的最大动力！