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

目次
1、JUC（java.util.concurrent）
1.1、Callable 接口
1.2、ReentrantLock 可重入锁
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 的创建方法。

1.     public static void main(String[] args) throws ExecutionException, InterruptedException {
2.         Callable<Integer> callable = new Callable<>() {
3.             @Override
4.             public Integer call() throws Exception {
5.                 int ret = 0;
6.                 for (int i = 1; i <= 1000; i++) {
7.                     ret += i;
8.                 }
9.                 return ret;
10.             }
11.         };
13.         //引入 FutureTask 类，作为 Thread 和 callable 的 “粘合剂”
14.         FutureTask<Integer> futureTask = new FutureTask<>(callable);
15.         Thread t = new Thread(futureTask);
16.         t.start();
18.         //取餐号，使用 futureTask 获取到结果，具有阻塞功能
19.         System.out.println(futureTask.get());
20.     }

复制代码

  基于 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 自增 5w 的操作

1. package thread;
3. import java.util.concurrent.Semaphore;
5. public class ThreadDemo38 {
6.     private static int count = 0;
8.     public static void main(String[] args) throws InterruptedException {
9.         //信息量设置为 1
10.         Semaphore semaphore = new Semaphore(1);
12.         Thread t1 = new Thread(() -> {
13.             for (int i = 0; i < 50000; i++) {
14.                 try {
15.                     semaphore.acquire();
16.                 } catch (InterruptedException e) {
17.                     throw new RuntimeException(e);
18.                 }
19.                 count++;
20.                 semaphore.release();
21.             }
22.         });
23.         Thread t2 = new Thread(() -> {
24.             for (int i = 0; i < 50000; i++) {
25.                 try {
26.                     semaphore.acquire();
27.                 } catch (InterruptedException e) {
28.                     throw new RuntimeException(e);
29.                 }
30.                 count++;
31.                 semaphore.release();
32.             }
33.         });
34.         t1.start();
35.         t2.start();
36.         t1.join();
37.         t2.join();
39.         System.out.println("count = " + count);
40.     }
41. }

复制代码

1.4、CountDownLatch

针对特定场景下办理题目标小工具。作用：同时等候 N 个任务执行结束。
好比，多线程执行一个任务，把大的任务拆分成几个部门，由每个线程分别执行。“多线程下载”：idm，比特彗星。

1. package thread;
3. import java.util.Random;
4. import java.util.concurrent.CountDownLatch;
6. public class ThreadDemo39 {
7.     public static void main(String[] args) throws InterruptedException {
8.         // 1. 此处构造方法中写 10, 意思是有 10 个线程/任务
9.         CountDownLatch latch = new CountDownLatch(10);
11.         // 创建出 10 个线程负责下载.
12.         for (int i = 0; i < 10; i++) {
13.             int id = i;
14.             Thread t = new Thread(() -> {
15.                 Random random = new Random();
16.                 // [0, 5)
17.                 int time = (random.nextInt(5) + 1) * 1000;
18.                 System.out.println("线程 " + id + " 开始下载");
19.                 try {
20.                     Thread.sleep(time);
21.                 } catch (InterruptedException e) {
22.                     throw new RuntimeException(e);
23.                 }
24.                 System.out.println("线程 " + id + " 结束下载");
25.                 // 2. 告知 countDownLatch 我执行结束了.
26.                 latch.countDown();
27.             });
28.             t.start();
29.         }
31.         // 3. 通过这个 await 操作来【等待所有任务结束】. 也就是 countDown 被调用 10 次了.
32.         latch.await();
33.         System.out.println("所有任务都已经完成了!");
34.     }
35. }

复制代码

  

• 每个任务执行完毕，都调用 latch.countDown()。在 CountDownLatch 内部的计数器同时自减。
  
• 主线程中利用 latch.await()； 阻塞等候所有任务执行完毕，相当于计数器为 0 了。
  

  

【博主保举】 
【网络原理】TCP 协议中比较重要的一些特性（三）-CSDN博客

https://blog.csdn.net/zzzzzhxxx/article/details/136597348?spm=1001.2014.3001.5501【Java多线程】关于多线程的一些案例 —— 单例模式中的饿汉模式和懒汉模式以及阻塞队列-CSDN博客

https://blog.csdn.net/zzzzzhxxx/article/details/136688859?spm=1001.2014.3001.5501【网络原理】TCP 协议中比较重要的一些特性（二）-CSDN博客

https://blog.csdn.net/zzzzzhxxx/article/details/136579333?spm=1001.2014.3001.5501

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

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

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

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。