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

蔚落 2024-04-20 11:58 49阅读 0赞

**目录**

1、JUC（java.util.concurrent）

1.1、Callable 接口

1.2、ReentrantLock 可重入锁

1.3、Semaphore 信号量

1.4、CountDownLatch

--------------------

![95b06e92a42647e986b169066dc0889e.gif][]

## 1、JUC（java.util.concurrent） ##

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

### 1.1、Callable 接口 ###

[【Java多线程】Thread类的基本用法-CSDN博客![icon-default.png?t=N7T8][icon-default.png_t_N7T8]https://blog.csdn.net/zzzzzhxxx/article/details/136121421?spm=1001.2014.3001.5501][Java_Thread_-CSDN_icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_zzzzzhxxx_article_details_136121421_spm_1001.2014.3001.5501]

> 往期的博客中对创建线程的几种方式进行过说明，有如下几种：
> 
> 1、继承 Thread（包含了匿名内部类的方式）
> 
> 2、实现 Runnable（包含了匿名内部类的方式）
> 
> 3、基于 lambda 表达式

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

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 的操作**

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，比特彗星。

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 了。

![3451e35db5774c8799aa5253be640c33.gif][]

**【博主推荐】**

[【网络原理】TCP 协议中比较重要的一些特性（三）-CSDN博客![icon-default.png?t=N7T8][icon-default.png_t_N7T8]https://blog.csdn.net/zzzzzhxxx/article/details/136597348?spm=1001.2014.3001.5501][TCP _-CSDN_icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_zzzzzhxxx_article_details_136597348_spm_1001.2014.3001.5501][【Java多线程】关于多线程的一些案例 —— 单例模式中的饿汉模式和懒汉模式以及阻塞队列-CSDN博客![icon-default.png?t=N7T8][icon-default.png_t_N7T8]https://blog.csdn.net/zzzzzhxxx/article/details/136688859?spm=1001.2014.3001.5501][Java_ _ _-CSDN_icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_zzzzzhxxx_article_details_136688859_spm_1001.2014.3001.5501][【网络原理】TCP 协议中比较重要的一些特性（二）-CSDN博客![icon-default.png?t=N7T8][icon-default.png_t_N7T8]https://blog.csdn.net/zzzzzhxxx/article/details/136579333?spm=1001.2014.3001.5501][TCP _-CSDN_icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_zzzzzhxxx_article_details_136579333_spm_1001.2014.3001.5501]

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

[95b06e92a42647e986b169066dc0889e.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/b7eb8b8079334d67b765e2f10d80cfd1.gif
[icon-default.png_t_N7T8]: https://csdnimg.cn/release/blog_editor_html/release2.3.6/ckeditor/plugins/CsdnLink/icons/icon-default.png?t=N7T8
[Java_Thread_-CSDN_icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_zzzzzhxxx_article_details_136121421_spm_1001.2014.3001.5501]: https://blog.csdn.net/zzzzzhxxx/article/details/136121421?spm=1001.2014.3001.5501
[3451e35db5774c8799aa5253be640c33.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/8cdcc1daf593466196781f5a3249eb02.gif
[TCP _-CSDN_icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_zzzzzhxxx_article_details_136597348_spm_1001.2014.3001.5501]: https://blog.csdn.net/zzzzzhxxx/article/details/136597348?spm=1001.2014.3001.5501
[Java_ _ _-CSDN_icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_zzzzzhxxx_article_details_136688859_spm_1001.2014.3001.5501]: https://blog.csdn.net/zzzzzhxxx/article/details/136688859?spm=1001.2014.3001.5501
[TCP _-CSDN_icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_zzzzzhxxx_article_details_136579333_spm_1001.2014.3001.5501]: https://blog.csdn.net/zzzzzhxxx/article/details/136579333?spm=1001.2014.3001.5501