【多线程】JUC的常见类，Callable接口，ReentranLock，Semaphore，CountDownLatch

ops/2024/9/24 21:22:17/

JUC：java.util.concurrent

一、Callable 接⼝

接口方法
Callablecall，带有返回值
Runnablerun，void
所以创建一个线程，希望它给你返回一个结果，那么使用 Callable 更加方便一些

比如，创建一个线程，让这个线程计算：1+2+3+4+…+1000=?

java">//使用Runnable接口
public class Demo {  private static int result;  public static void main(String[] args) throws InterruptedException {  Thread t = new Thread(() -> {  int sum = 0;  for (int i = 0; i < 1000; i++) {  sum += i;  }        });        t.start();  t.join();  System.out.println(“result=” + result);  }
}
  • 当前代码可以解决问题，但不够优雅，必须得引入一个成员变量 result

相比之下，Collable 就可以解决上述问题：

java">import java.util.concurrent.Callable;  
import java.util.concurrent.ExecutionException;  
import java.util.concurrent.FutureTask;  public class Demo3 {  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 = 0; i < 1000; i++) {  sum += i;  }                return sum;  }        };        FutureTask<Integer> futureTask = new FutureTask<>(callable);  Thread t = new Thread(futureTask); //Thread  t.start();  //后续需要通过 futureTask 来拿到最终的结果  System.out.println(futureTask.get());  }
}
  • Thread 不能直接传入 callable 作为参数，需要传入实例化的 Callable 对象 callable 实例化一个 FutureTask 对象 futureTask，再将这个 futureTask 对象创建出线程
  • 并且后面要拿到 sum 的值，也需要通过 futureTask
  • futureTask 的 get 操作是带有阻塞功能的
    • 当前 t 线程还没执行完，get 就会阻塞
    • 直到 t 线程执行完之后，get 才会返回
  • 比如说你去吃麻辣烫，夹好菜后，服务员会给你一个“号码牌”，方便你后续取餐。这里通过 FutureTask 实例化出的对象 futureTask 就相当于是号码牌，你通过 Callable 实例出的 callable 对象就相当于是你夹的菜。你是通过你夹的菜（callable）拿到号码牌（futureTask），最后你想要拿到菜，也得通过号码牌（futureTask）拿到

创建线程的方式：

  1. 直接继承 Thread
  2. 使用 Runnable
  3. 使用 Callable
  4. 使用 lambda
  5. 使用线程池

二、ReentrantLock

  • 可重入锁
  • synchronized 只是 Java 提供的一种加锁的方式
  • ReentrantLock 属于经典风格的锁，通过 lock 和 unlock 方法来完成加锁和解锁
java">import java.util.concurrent.locks.ReentrantLock;public class Demo {  private static int count = 0;  public static void main(String[] args) throws InterruptedException {  ReentrantLock locker = new ReentrantLock();  Thread t1 = new Thread(() -> {  for (int i = 0; i < 50000; i++) {  locker.lock();  count++;  locker.unlock();  }        });        Thread t2 = new Thread(() -> {  for (int i = 0; i < 50000; i++) {  locker.lock();  count++;  locker.unlock();  }        });        t1.start();  t2.start();  t1.join();  t2.join();  System.out.println("count=" + count);  }
}

synchronized 和 ReentrantLock 的差异

实际开发中，大多数情况下，使用 synchronized 即可，但 ReentrantLock 相比于 synchronized 还是有一些差异的

  1. synchronized 属于关键字（底层是通过 JVM 的 C++代码实现的）
    ReentrantLock 测试标准库提供的类，通过 Java 代码实现的

  2. synchronized 通过代码块控制加锁解锁
    ReentrantLock 通过调用 lock/unlock 方法来完成，unlock 可能会遗漏，要确保能执行到 unlock（通常会把 unlock 放在 finally 中）

  3. ReentrantLock 提供了 tryLock 这样的加锁风格（重点）

    • 前面介绍的加锁，都是发现锁被别人占用了，就阻塞等待
    • 而 tryLock 在加锁失败的时候，不会阻塞，而是直接返回，并且通过返回值来反馈是加锁成功还是失败
    • 坚持不一定成功，但是放弃了一定轻松~（摆烂态度）

  4. ReentrantLock 还提供了公平锁的实现（重点）

    • 它默认是非公平的，但可以在构造方法中，将参数设为 true，将其设为公平锁

  5. ReentrantLock 还提供了功能更强的“等待通知机制”

    • 基于 Condition 类，功能要比 wait/notify 更强一些

三、信号量 Semaphore

也称为“信号灯”（开船的水手，旗语）

你去车库停车，如何知道是否还有空位？
现在的停车场，一般的入口处，就会有一个“电子牌”，会显示有多少个空闲车位

  • 有车开进去了，上述的计数 -1
  • 有车开出来了，上述的计数 +1
  • 如果计数为 0 了，说明没空位了

这里的“电子牌”就像是一个“信号量”，信号量是一个计数器，通过计数器衡量“可用资源”的个数

  • 申请资源（acquire）：让计数器 -1（“P”操作）
  • 释放资源（release）：让计数器 +1（“V”操作）
  • 如果计数器为 0 了，继续申请，就会出现阻塞
    所以信号量的操作也称为“PV 操作”

操作系统本身提供了信号量实现，JVM 把操作系统的信号量封装了一下，我们直接使用就可以了

java">import java.util.concurrent.Semaphore;  public class Demo5 {  public static void main(String[] args) throws InterruptedException {  //参数为可用资源的个数，计数器的初始值  Semaphore semaphore = new Semaphore(3);  semaphore.acquire();  System.out.println("申请一个资源1");  semaphore.acquire();  System.out.println("申请一个资源2");  semaphore.acquire();  System.out.println("申请一个资源3");  semaphore.acquire();  System.out.println("申请一个资源4");  }
}
//运行结果
申请一个资源1
申请一个资源2
申请一个资源3
  • 初始化的信号量为 3
  • 申请了三个资源后，没空位了，计数器为 0 了，就堵塞住了

若在这里面释放一次资源，就可以将资源 4 申请进去：

java">import java.util.concurrent.Semaphore;  public class Demo5 {  public static void main(String[] args) throws InterruptedException {  //参数为可用资源的个数，计数器的初始值  Semaphore semaphore = new Semaphore(3);  semaphore.acquire();  System.out.println("申请一个资源1");  semaphore.acquire();  System.out.println("申请一个资源2");  semaphore.acquire();  System.out.println("申请一个资源3");  semaphore.release();  System.out.println("释放一个资源");  semaphore.acquire();  System.out.println("申请一个资源4");  }
}
//运行结果
申请一个资源1
申请一个资源2
申请一个资源3
释放一个资源
申请一个资源4

平替加锁解锁

  • 在需要加锁的时候，可以设置一个信号量，初始化一个资源
  • 谁要用的时候就申请这个资源，用完之后再释放
  • 这样的话，申请到唯一资源的线程执行操作的时候，就不会有其他的线程进行操作了
java">import java.util.concurrent.Semaphore;  public class Demo4 {  private static int count = 0;  public static void main(String[] args) throws InterruptedException {  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 的信号量，就相当一个锁，资源要么是 1，要么是 0，所以也称为“二元信号量”

四、CountDownLatch

“锁存器”

很多时候，需要把一个大的任务，拆成多个小的任务，通过多线程/线程池来执行。如何衡量，所有的任务都执行完毕了？

  • 比如“多线程下载”
  • 浏览器的下载，一般是单线程的，下载速度是有限的（一秒 2-3 MB）
  • 但是可以通过多线程的方式提高下载速度
    就可以使用专门的下载工具，通过多个线程，和服务器建立多个网络连接（服务器进行网速限制都是针对一个连接做出的限制），那如果我创建 10-20 个线程，那么下载的总速度就能大幅度提高
  • 多个线程进行一起操作，每个线程下载一部分，所有线程下载完毕再进行拼装
java">import java.util.concurrent.CountDownLatch;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  public class Demo6 {  public static void main(String[] args) throws InterruptedException {  ExecutorService executorService = Executors.newFixedThreadPool(4);  //构造方法的个数，就是拆分出来的任务数量  CountDownLatch countDownLatch = new CountDownLatch(20);  for (int i = 0; i < 20; i++) {  int id = i;  executorService.submit(() -> {  System.out.println("下载任务" + id + "开始执行");  try {  Thread.sleep(3000);  } catch (InterruptedException e) {  throw new RuntimeException(e);  }                System.out.println("下载任务" + id + "结束执行");  //完毕 over！  countDownLatch.countDown();  });        }        // 当 countDownLatch 收到了 20 个“完成”，所有的任务就都完成了  // await => all wait  // await 这个词是计算机术语，“等待所有”  countDownLatch.await();  System.out.println("所有任务都完成");  }
}
  • CountDownLatch 一般都是结合线程池进行使用
  • 借助 CountDownLatch 就能衡量出当前任务是否整体执行结束

上面这些再实际开发中用的布套多，但面试可能问到，特别是“ReentrantLock”和“Semaphore”

五、相关面试题

image.png

image.png

image.png


http://www.ppmy.cn/ops/93007.html

相关文章

【扒代码】regression_head.py

【扒代码】regression_head.py

import torch from torch import nnclass UpsamplingLayer(nn.Module):# 初始化 UpsamplingLayer 类def __init__(self, in_channels, out_channels, leakyTrue):super(UpsamplingLayer, self).__init__() # 调用基类的初始化方法# 初始化一个序列模型&#xff0c;包含卷积层、…
阅读更多...
Spring中dbUtil的概念和搭建使用

Spring中dbUtil的概念和搭建使用

目录 1、什么是dbUtil 2、lombok插件 3、dbUtil通过xml来实现 4、SpringJunit的作用和效果 &#xff08;1&#xff09;标记测试方法和配置方法的注解 5、dbUtil通过注释来实现 6、dbUtil通过config配置类来实现 7、dbUtil通过aop的XML的实现 &#xff08;1&#xff09…
阅读更多...
【WebRTC指南】对等连接

【WebRTC指南】对等连接

开始使用对等连接 点对点连接是 WebRTC 规范的一部分，该规范旨在对计算机上的两点应用进行连接，以使用点对点协议进行通信。对等设备之间的通信可以是视频、音频或任意二进制数据（适用于支持 RTCDataChannel API 的客户端）。为了发现两个对等端如何连接，两个客户端都需要…
阅读更多...
Vue3详细介绍，正则采集器所用前端框架

Vue3详细介绍，正则采集器所用前端框架

Vue3 引入了一个全新的响应式系统&#xff0c;它是基于ES6的Proxy特性构建的。这个系统使得 Vue 能够更加高效地追踪数据的变化&#xff0c;并在数据发生变化时自动更新DOM。响应式系统的核心是"可观察"&#xff0c;当数据变化时&#xff0c;视图会响应这些变化并重新…
阅读更多...
(回溯) LeetCode 40. 组合总和II

(回溯) LeetCode 40. 组合总和II

原题链接 一. 题目描述 给定一个候选人编号的集合 candidates 和一个目标数 target &#xff0c;找出 candidates 中所有可以使数字和为 target 的组合。 candidates 中的每个数字在每个组合中只能使用 一次 。 注意&#xff1a;解集不能包含重复的组合。 示例 1: 输入: …
阅读更多...
SQL注入之二次，加解密，DNS注入

SQL注入之二次，加解密，DNS注入

加解密注入 在注入的时候&#xff0c;对变量做了加密操作&#xff0c;比如说?id1正常显示&#xff0c;但是代码对1进行了加密&#xff0c;这个时候想用?id1 and 11去判断&#xff0c;就得把1 and 11整体按照网站的方式加密&#xff0c;再去注入 二次注入 无法通过手动注入…
阅读更多...
BP创建客户报错（尚未将分组 Z000 分配给任何客户账户组）

BP创建客户报错（尚未将分组 Z000 分配给任何客户账户组）

项目场景&#xff1a; SAP中使用BP创建客户主数据的&#xff0c;并保存 问题描述 尚未将分组 Z000 分配给任何客户账户组 消息号 FSBP_ECC004 原因分析&#xff1a; 后台配置有异常 解决方案&#xff1a; 处理方法&#xff1a; 路径&#xff1a; IMG->SAP用户化实施指南-…
阅读更多...
关于k8s集群Pod启动过程

关于k8s集群Pod启动过程

目录 1.Pod启动阶段&#xff08;相位 phase&#xff09; 1.1 phase的可能状态 2.Pod故障排除步骤 3.总结 1.Pod启动阶段&#xff08;相位 phase&#xff09; Pod 创建完之后&#xff0c;一直到持久运行起来&#xff0c;中间有很多步骤&#xff0c;也就有很多出错的可能&…
阅读更多...
最新文章

Copyright @ 2022~2023