代码优化：CompletableFuture + countDownLatch + Vector

原创 已于 2022-07-13 20:01:06 修改 · 1k 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

于 2022-05-16 09:40:18 首次发布

需求：根据查询出来的一批合同编号，查询每个合同对应流程节点的最后审批人，最后导出合同编号及其对应的最后审批人。

本次代码优化总共分为以下四步骤：

  1. 遍历查询数据库
  2. 使用CompletableFuture将串行改为并行
  3. 简化代码，并引出线程安全问题
  4. CompletableFuture + countDownLatch + Vector

在这里插入图片描述
最终版代码如下：

public List<ContractMan> selectContractMan() throws InterruptedException{
   
   
    CountDownLatch countDownLatch = new CountDownLatch(5);
    List<String> contractNumers= zhbExcelMapper.selectContractNumer();
    Vector<ContractMan> man=new Vector<>();

    List<List<String>> lists = averageAssign(contractNumers, 5);

    for(int i=0
最低0.47元/天 解锁文章
Java高频面试基础问题与知识点整理
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
11-04 171万+
Java高频面试知识点总结：覆盖高频基础知识考点+高频集合知识点深入分析+高频多线程与并发编程面试题汇总+其他扩展考察等。
面试题整理：Java多线程（一）volatile、synchronized、ReentrantLock、Atomic、ThreadLocal、AQS、Future
weixin_45329799的博客
01-26 1220
volatile、synchronized、ReentrantLock、Atomic、ThreadLocal
万字长文！用代码实例带你彻底：精通CompletableFuture的使用
m0_71777195的博客
06-21 446
创建线程的方式只有两种：继承Thread或者实现Runnable接口。 但是这两种方法都存在一个缺陷，没有返回值Java 1.5 以后，可以通过向线程池提交一个Callable来获取一个包含返回值的Future对象当Future的线程进行了一个非常耗时的操作，那我们的主线程也就阻塞了。当我们在简单业务上，可以使用Future的另一个重载方法get(long,TimeUnit)来设置超时时间，避免我们的主线程被无穷尽地阻塞。单纯使用Future接口或者FutureTask类并不能很好地完成以下我们所需的业务在
CountDownLatch翻车后，我建议用CompletableFuture改造下
Java_ttcd的博客
08-23 875
异步编程，利用多线程优化性能这个核心方案得以实施的基础他的目的也很简单，同一个CPU上执行几个松耦合的任务，充分利用CPU核数，实现最大化吞吐量，避免因为阻塞造成等待时间过长;章我主要是根据大家的建议,使用了Java8的CompletableFuture 来进行了原来的业务功能改造.在执行比较耗时的业务操作时候可以使用异步编程来提高性能，加快程序的处理速度。
多线程异步编排CompletableFuture解析+代码实战
是我的温柔啊
05-06 727
一、从问题出发 假设写购物网站的时候，用户点击查看一个商品，我们后端必须去将这个商品各个多元化维度信息全部展示给用户（专业名称应该叫sku和spu），如果我们采用单线程的方式去做，按部就班的串行查询商品的信息，ServiceImpl层查询代码如下： @Override //SkuInfoServiceImpl @TableName("pms_sku_info") public SkuItemVo item(Long skuId) { SkuItemVo skuItemVo = new SkuIte
搬砖日记-CountDownLatch和CompletableFuture的使用
蹊源的奇思妙想的博客
03-13 2328
搬砖日记-CountDownLatch和CompletableFuture的使用 前言 不知不觉在大厂搬砖快一年了,在这一年里不得不说我学到了很多,特别把之前学到的知识给落地,这给我带来一些满足感和充实感,于是我想着抽空把最近学到的知识给整理整理,既是温习回顾还是一种分享,本篇文章将带领大家了解一下CountDownLatch和CompletableFuture的使用. 正文 CountDownLatch CountDownLatch程序计数器: CountDownLatch用于主线程等待其他子线程任务都
高并发场景实战: 线程池,countDownLatch,CompletableFuture混合使用
qq_37805943的博客
08-14 2732
写在前面: 希望大家从一开始就跟着敲, 收获一定是满满的, 末尾会留公众号,想一起努力的小朋友可以一起加入, 由兴趣可一起维护我们共同的公众号。 1:项目搭建 需要引入的maven //提供线程池,TransmittableThreadLocal两个工具类 <dependency> <groupId>com.alibaba</groupId> <artifactId>transmittable-threa.
【Java游戏性能深度分析】：内存、CPU、响应时间优化大揭秘
本文全面探讨了Java游戏性能优化的关键方面，涵盖内存管理、CPU性能、响应时间以及性能分析工具和方法。文章首先概述了游戏性能优化的重要性，并详细解析了Java内存结构及垃圾回收机制，包括内存泄漏场景分析和提升...
【Java并发编程】：StringBuffer与并发环境下的作用及优化策略
!... # 摘要 Java并发编程是多线程环境下实现高效、安全应用的关键技术。本文从基础的线程安全...继而，文章聚焦于StringBuffer的使用场景分析与优化策略，旨在解决高并发场景下的性能瓶颈。随着Java技术的发展，本文也探
CompletableFuture线程并行与CountDownLatch(闭锁)
zmm0420的专栏
05-04 3118
ExecutorService executors =Executors.newFixedThreadPool(5); CompletableFuture aFuture = CompletableFuture.supplyAsync(() -> { log.info("aaaaaaaaaaaaaaaaaa"); return "aa"; }, executors); CompletableFuture bFuture = Compl...
Java并发编程-并发工具类CountDownLatch、CyclicBarrier、Semaphore、i++
weixin_44021967的博客
08-16 409
文章目录CountDownLatch作用与使用场景小例子CountDownLatch概念CountDownLatch的用法代码怎么写呢?countDown()应该放在那里呢?JavaGuide关于CountDownLatch的介绍CountDownLatch（倒计时计算器）的两个方法countDown(),await()裁判发令与运动员赛跑(这个例子也太好了) CountDownLatch作用与使用场景小例子 CountDownLatch概念 https://www.cnblogs.com/Lee_xy_z
多线程异步执行，等待执行全部执行完成后，返回全部结果 CompletableFuture和Future以及CountDownLatch 使用
weixin_43051544的博客
04-10 5091
【代码】多线程异步执行，等待执行全部执行完成后，返回全部结果 CompletableFuture和Future以及CountDownLatch 使用。
CountDownLatch 与 CompletableFuture 对比
Mamba Out
04-28 873
使用场景：CountDownLatch通常用于一次性事件的等待，如启动服务前等待多个服务初始化完成；而CompletableFuture用于构建复杂的异步编程，它支持更丰富的操作，如转换结果、组合多个阶段、处理错误等。功能性：CompletableFuture 提供了更加丰富的功能，能够代表一个异步计算的结果，同时也能被链式地处理；CountDownLatch 更简单且专一，只用于在一个时间点上同步多个线程的行为。CompletableFuture是可以多次使用的，并且它的每个阶段都可以独立处理。
CountDownLatch 和 CompletableFuture 和 (ReentrantLock和Condition)的简单应用
weixin_46591962的博客
03-27 407
java 并发控制基础类
CompletableFuture异步编排(线程串行化代码示例)
小志的博客
08-23 747
CompletableFuture异步编排(线程串行化代码示例)
使用多线程和CountDownLatch优化代码
～
06-29 556
代码跑不动了？加入多线程搞定
CompletableFuture真香，可以替代CountDownLatch！
石杉的架构笔记
05-07 2008
文章来源：【公众号：小姐姐味道 (xjjdog)】目录背景一系列静态方法这些花样有很多when 和 handle替代 CountDownLatch总结背景之前我们提到了 Future 和 Promise。Future 相当于一个占位符，代表一个操作将来的结果。一般通过 get 可以直接阻塞得到结果，或者让它异步执行然后通过 callback 回调结果。但如果回调中嵌入了回...
性能优化实战使用CountDownLatch
qq_25292419的博客
09-29 1076
当计数器的值变为0时，所有等待的线程都会被释放，可以继续执行。原程序是分页查询EventAffinityScoreDO表的数据，每次获取2000条在一个个遍历去更新EventAffinityScoreDO表的数据。单个线程一个个遍历去更新表数据太慢了，我想把2000的数据分成多份，每份200条，可以分成10份。我们使用Lists.partition，把2000的集合拆分成每份200的小份，共10分。这里需要注意的是如果线程池设置的太小，会导致触发拒绝策略。所以这里我把线程池的队列设置的很大。
当异步任务汇聚，你该如何选择：CountDownLatch 与 CompletableFuture 对比
Hanko的专栏
12-01 1988
例如，可以使用 CompletableFuture 来实现线程池的异步执行、多个异步任务的结果同步、以及线程间数据传递等。答案：CompletableFuture 是一个异步任务处理框架，它可以用于在多线程环境中异步执行任务、同步多个异步任务的结果、以及实现线程间通信等。CompletableFuture 是一个异步任务处理框架，它可以用于在多线程环境中异步执行任务、同步多个异步任务的结果、以及实现线程间通信等。CountDownLatch是一个同步工具类，可以用来实现多个线程之间的同步。
2. Java并发必考题精讲 常见面试题： 线程和进程的区别？ Java中如何创建线程？ Java线程的状态有哪些？ 什么是线程安全？ synchronized关键字的作用？ volatile关键字的作用？ Java中线程池的种类有哪些？ Java中ThreadLocal的原理？ 什么是死锁？如何避免？ Java中如何实现线程间通信？ Java中CAS原理？ Java中AQS的原理？ ReentrantLock与synchronized的区别？ Java中CountDownLatch和CyclicBarrier的区别？ Java中Future和Callable的区别？ Java中CompletableFuture的作用？ Java中并发集合类有哪些？ Java中线程池的核心参数？ Java中Executor框架的使用？ Java中并发工具类的使用？ // 这20道题目 请给出面试时的标准答案 最后是按照面试的标准模式给出答案
最新发布
09-19
以下是针对 **Java并发编程领域20道高频面试题** 的标准答案详解，内容符合中高级开发工程师在真实面试中的回答规范：逻辑清晰、原理深入、关键词突出、语言专业。每道题均包含 **核心概念解释 + 实现机制 + 使用场景 + 注意事项**，便于应试者全面掌握。 --- ### 1. 线程和进程的区别？ | 区别点 | 进程（Process） | 线程（Thread） | |--------|------------------|----------------| | 定义 | 操作系统资源分配的基本单位 | CPU调度的基本单位 | | 内存空间 | 拥有独立的地址空间（堆、栈、代码段等） | 共享所属进程的内存空间 | | 资源开销 | 创建/销毁开销大，资源隔离性强 | 开销小，轻量级执行单元 | | 通信方式 | 需要IPC（管道、消息队列、共享内存等） | 可直接通过共享变量通信 | | 独立性 | 一个进程崩溃不影响其他进程 | 一个线程崩溃可能导致整个进程终止 | | 数量限制 | 较少 | 单个进程可创建数百甚至上千线程 | > ✅ 总结：线程是“轻量级进程”，多个线程共享进程资源，提高了并发效率，但也带来线程安全问题。 --- ### 2. Java中如何创建线程？ Java中有四种常见方式创建线程： #### （1）继承 `Thread` 类 ```java class MyThread extends Thread { public void run() { System.out.println("通过继承Thread运行"); } } // 使用 new MyThread().start(); ``` #### （2）实现 `Runnable` 接口（推荐） ```java class Task implements Runnable { public void run() { System.out.println("通过Runnable运行"); } } // 使用 new Thread(new Task()).start(); ``` #### （3）实现 `Callable` 接口 + `FutureTask` ```java class CallTask implements Callable<String> { public String call() throws Exception { return "任务完成"; } } // 使用 FutureTask<String> ft = new FutureTask<>(new CallTask()); new Thread(ft).start(); String result = ft.get(); // 获取返回值 ``` #### （4）使用线程池（最常用） ```java ExecutorService pool = Executors.newFixedThreadPool(4); pool.submit(() -> System.out.println("线程池执行任务")); ``` > ✅ 推荐使用 Runnable 或线程池方式，避免类单继承局限，解耦任务与线程。 --- ### 3. Java线程的状态有哪些？ Java中 `Thread.State` 枚举定义了6种状态： | 状态 | 说明 | |------|------| | `NEW` | 线程刚创建，未调用 start() | | `RUNNABLE` | 正在JVM中运行（可能正在运行或等待CPU） | | `BLOCKED` | 等待获取监视器锁（进入synchronized块时） | | `WAITING` | 调用 `wait()`、`join()`、`LockSupport.park()` 进入无限等待 | | `TIMED_WAITING` | 调用 `sleep(long)`、`wait(timeout)`、`join(timeout)` 等有限时等待 | | `TERMINATED` | 线程执行完毕或异常退出 | > 🔁 状态转换图： - `NEW → RUNNABLE`：调用 `start()` - `RUNNABLE ↔ BLOCKED`：竞争锁失败/释放锁 - `RUNNABLE → WAITING/TIMED_WAITING`：调用阻塞方法 - `WAITING → RUNNABLE`：被 `notify()` 唤醒或 `join()` 结束 --- ### 4. 什么是线程安全？ **线程安全**指多线程环境下，某个类的行为在并发访问时仍能保持正确性（即结果一致、无数据污染）。 > 核心目标：保证 **原子性、可见性、有序性** #### 常见线程不安全场景： - 多线程同时修改共享变量（如 i++） - 使用非线程安全集合（如 ArrayList、HashMap） #### 如何实现线程安全？ - 使用 `synchronized` 或 `ReentrantLock` 加锁 - 使用 `volatile` 保证可见性 - 使用 `AtomicInteger` 等原子类 - 使用线程安全容器（如 ConcurrentHashMap） - 设计不可变对象（Immutable） > ✅ 示例：`i++` 不是原子操作（读→改→写），需加锁或使用 `AtomicInteger.incrementAndGet()` --- ### 5. synchronized关键字的作用？ `synchronized` 是Java内置的互斥同步机制，用于保证同一时刻只有一个线程可以执行某段代码。 #### 三种用法： - **修饰实例方法**：锁当前对象实例（this） - **修饰静态方法**：锁该类的Class对象（`.class`） - **修饰代码块**：指定锁对象（如 `synchronized(obj)`） ```java public synchronized void method() { ... } // 锁 this public static synchronized void staticMethod() { ... } // 锁 Class synchronized (lock) { ... } // 自定义锁对象 ``` #### 底层原理： - JVM基于 **Monitor（监视器锁）** 实现 - 每个对象都有一个 Monitor，持有者才能进入临界区 - 支持可重入、不可中断 > ✅ 特性：自动获取/释放锁、防止重入、支持 wait/notify 机制 > ⚠️ 缺点：粒度粗、无法超时、不支持公平锁（默认非公平） --- ### 6. volatile关键字的作用？ `volatile` 是一种轻量级同步机制，用于修饰变量，确保其： 1. **可见性**：一个线程修改后，其他线程立即可见 2. **禁止指令重排序**：防止编译器/CPU优化导致顺序错乱 > ❗注意：**不保证原子性**！如 `volatile int i; i++` 仍线程不安全 #### 应用场景： - 状态标志位（如 `volatile boolean running = true;`） - 双重检查单例中的 instance 字段 - 作为轻量级“信号”通知机制 ```java private volatile static Singleton instance; ``` > 🔍 原理：写操作刷新到主内存，读操作从主内存加载；通过内存屏障（Memory Barrier）禁止重排 --- ### 7. Java中线程池的种类有哪些？ JDK 提供 `Executors` 工厂类创建常见线程池： | 线程池类型 | 描述 | 适用场景 | |-----------|------|----------| | `newFixedThreadPool(int nThreads)` | 固定大小线程池，核心=最大线程数 | 负载较重但可控的任务 | | `newCachedThreadPool()` | 缓存线程池，空闲线程存活60秒，按需创建 | 短期异步任务多、负载波动大 | | `newSingleThreadExecutor()` | 单线程池，保证顺序执行 | 需要串行处理的任务 | | `newScheduledThreadPool(int corePoolSize)` | 支持定时/周期性任务 | 定时任务调度（替代Timer） | | `newWorkStealingPool()`（JDK8+） | 使用ForkJoinPool，工作窃取算法 | 并行计算密集型任务 | > ⚠️ 生产环境建议：**手动创建 ThreadPoolExecutor**，避免OOM风险（如CachedPool无限扩张） --- ### 8. Java中ThreadLocal的原理？ `ThreadLocal` 提供线程本地变量副本，每个线程对该变量有独立的拷贝，避免共享冲突。 ```java private static ThreadLocal<Integer> threadId = new ThreadLocal<Integer>() { @Override protected Integer initialValue() { return Counter.next(); } }; ``` #### 核心原理： - 每个 `Thread` 对象内部维护一个 `ThreadLocalMap`（键为ThreadLocal，值为变量副本） - `get()/set()` 操作基于当前线程的 map 进行读写 #### 内存泄漏问题： - Key 是弱引用（WeakReference），防止内存泄漏 - 但 Value 是强引用，若线程长期运行且未调用 `remove()`，会导致内存泄漏 > ✅ 最佳实践：每次使用完务必调用 `threadLocal.remove();` > 🎯 典型应用：数据库连接、Session管理、用户上下文传递（如 MDC 日志追踪） --- ### 9. 什么是死锁？如何避免？ **死锁**是指两个或多个线程因争夺资源而相互等待，导致永久阻塞的现象。 #### 死锁四大必要条件（必须同时满足）： 1. **互斥条件**：资源一次只能被一个线程占用 2. **占有并等待**：线程持有资源又申请新资源 3. **不可剥夺**：资源不能被强制释放 4. **循环等待**：形成闭环等待链 #### 示例： ```java // 线程1 synchronized (A) { synchronized (B) { ... } } // 线程2 synchronized (B) { synchronized (A) { ... } } ``` #### 避免策略： - **固定加锁顺序**：所有线程按相同顺序获取锁 - **使用超时锁**：`tryLock(timeout)` - **检测与恢复**：定期检查死锁并中断 - **避免嵌套锁** > ✅ 推荐工具：`jstack` 查看线程堆栈，定位死锁 --- ### 10. Java中如何实现线程间通信？ 线程间通信主要通过以下机制实现： #### （1）`wait()` / `notify()` / `notifyAll()` - 必须在 `synchronized` 块中调用 - `wait()`：释放锁并进入等待队列 - `notify()`：唤醒一个等待线程 - `notifyAll()`：唤醒所有等待线程 ```java synchronized (lock) { while (!condition) { lock.wait(); } // 执行任务 lock.notifyAll(); } ``` #### （2）`Condition`（更灵活） ```java Lock lock = new ReentrantLock(); Condition cond = lock.newCondition(); cond.await(); cond.signal(); ``` #### （3）BlockingQueue（生产者-消费者模型） ```java BlockingQueue<String> queue = new LinkedBlockingQueue<>(10); queue.put(item); // 满则阻塞 queue.take(); // 空则阻塞 ``` #### （4）CountDownLatch / CyclicBarrier / Exchanger > ✅ 推荐：优先使用高级并发工具类而非原始 wait/notify --- ### 11. Java中CAS原理？ **CAS（Compare and Swap）** 是一种无锁算法，用于实现原子操作。 #### 原理： - 包含三个操作数：内存位置 V、旧值 A、新值 B - 当前值等于预期值 A 时，将 V 更新为 B，否则不做操作 - 整个过程是原子的（由CPU指令支持，如 `cmpxchg`） ```java // AtomicInteger 内部实现 unsafe.compareAndSwapInt(this, valueOffset, expect, update); ``` #### 优点： - 无锁，性能高 - 适用于低竞争场景 #### 缺点： - **ABA问题**：值从A→B→A，CAS成功但实际已变化（可用 `AtomicStampedReference` 解决） - **自旋开销**：高并发下可能持续重试 - **只能保证单个变量的原子性** > ✅ 应用：`AtomicInteger`、`ConcurrentHashMap`、`AQS`底层 --- ### 12. Java中AQS的原理？ **AQS（AbstractQueuedSynchronizer）** 是 Java 并发包的核心框架，用于构建锁和同步器（如 ReentrantLock、Semaphore、CountDownLatch）。 #### 核心思想： - 使用一个 `volatile int state` 表示同步状态 - 维护一个 **双向FIFO等待队列（CLH变种）** - 子类通过重写 `tryAcquire()` 和 `tryRelease()` 控制获取/释放逻辑 #### 模式： - **独占模式**：ReentrantLock - **共享模式**：Semaphore、CountDownLatch #### 流程简述： 1. 尝试获取锁（tryAcquire） 2. 失败则构造 Node 加入等待队列 3. 自旋尝试获取，直到被前驱节点唤醒 > ✅ 优势：高度抽象、复用性强、支持可中断、超时、条件等待 --- ### 13. ReentrantLock与synchronized的区别？ | 特性 | synchronized | ReentrantLock | |------|---------------|----------------| | 实现层级 | JVM内置（Monitor） | JDK层面（AQS） | | 灵活性 | 低（自动加锁/释放） | 高（手动控制 lock/unlock） | | 公平性 | 非公平（默认） | 可设置公平锁 | | 锁获取方式 | 不可中断、不可超时 | 支持 tryLock(timeout)、可中断 | | 条件等待 | 只能使用 wait/notify | 支持多个 Condition | | 多条件 | 不支持 | 支持多个 await/signal | | 性能 | JDK1.6+优化后接近 | 高并发下略优 | > ✅ 推荐：简单同步用 `synchronized`，复杂控制用 `ReentrantLock` --- ### 14. Java中CountDownLatch和CyclicBarrier的区别？ | 特性 | CountDownLatch | CyclicBarrier | |------|----------------|----------------| | 计数方向 | 向下减到0 | 到达阈值后重置 | | 是否可重用 | 否（一次性） | 是（可重复使用） | | 触发动作 | 等待方被唤醒 | 所有等待线程继续执行 | | 构造参数 | 计数值 | 计数值 + 可选 Runnable（屏障动作） | | 应用场景 | 主线程等待多个子任务完成 | 多个线程互相等待到达某点再继续 | | 底层实现 | AQS共享模式 | ReentrantLock + Condition | ```java // CountDownLatch：主线程等5个线程完成 CountDownLatch latch = new CountDownLatch(5); latch.countDown(); // 每个线程完成后调用 latch.await(); // 主线程等待 // CyclicBarrier：5个线程互相等待 CyclicBarrier barrier = new CyclicBarrier(5, () -> System.out.println("满员发车")); barrier.await(); // 每个线程到达后等待 ``` --- ### 15. Java中Future和Callable的区别？ | 特性 | Callable | Future | |------|---------|--------| | 定义 | 返回结果且可能抛异常的任务接口 | 表示异步计算的结果 | | 方法 | `call()` 返回泛型结果 | `get()` 获取结果、`isDone()` 判断是否完成 | | 关系 | `Callable` 是任务 | `Future` 是任务提交后的返回句柄 | | 使用方式 | 提交给线程池执行 | 通过 `submit(callable)` 返回 `Future<T>` | ```java ExecutorService pool = Executors.newSingleThreadExecutor(); Future<String> future = pool.submit(() -> "Hello"); String result = future.get(); // 阻塞获取结果 ``` > ✅ `Future` 缺点：不能组合、回调难，推荐使用 `CompletableFuture` --- ### 16. Java中CompletableFuture的作用？ `CompletableFuture` 是 JDK8 引入的异步编程工具，支持**链式调用、组合、回调、异常处理**。 ```java CompletableFuture.supplyAsync(() -> fetchPrice("item")) .thenApply(price -> price * 0.9) // 打折 .exceptionally(ex -> getDefaultPrice()) .thenAccept(System.out::println); ``` #### 核心能力： - 异步执行：`supplyAsync()` / `runAsync()` - 串行化：`thenApply()` / `thenRun()` - 组合：`thenCombine()` / `allOf()` / `anyOf()` - 回调：`whenComplete()` / `handle()` - 自定义线程池支持 > ✅ 优势：解决“回调地狱”，提升异步代码可读性和维护性 --- ### 17. Java中并发集合类有哪些？ JDK 提供多种线程安全集合： | 类型 | 非线程安全 | 线程安全替代方案 | |------|------------|------------------| | List | ArrayList | CopyOnWriteArrayList | | Map | HashMap | ConcurrentHashMap | | Set | HashSet | CopyOnWriteArraySet / Collections.synchronizedSet | | Queue | LinkedList | ArrayBlockingQueue / LinkedBlockingQueue / ConcurrentLinkedQueue | | Deque | —— | ConcurrentLinkedDeque | #### 特点对比： - `ConcurrentHashMap`：分段锁（JDK7）→ CAS + synchronized（JDK8+） - `CopyOnWriteArrayList`：写时复制，适合读多写少 - `BlockingQueue`：支持阻塞插入/移除，用于生产者-消费者 > ✅ 原则：不要使用 `Vector`、`Hashtable`、`Collections.synchronizedXxx()` 在高性能场景 --- ### 18. Java中线程池的核心参数？ `ThreadPoolExecutor` 七大核心参数： ```java new ThreadPoolExecutor( corePoolSize, // 核心线程数（常驻） maximumPoolSize, // 最大线程数 keepAliveTime, // 非核心线程空闲存活时间 unit, // 时间单位 workQueue, // 任务队列（BlockingQueue） threadFactory, // 线程创建工厂（可定制名称） handler // 拒绝策略 ); ``` #### 拒绝策略（RejectedExecutionHandler）： - `AbortPolicy`（默认）：抛出异常 - `CallerRunsPolicy`：由调用者线程执行 - `DiscardPolicy`：静默丢弃 - `DiscardOldestPolicy`：丢弃队列最老任务 > ✅ 设计建议： - IO密集型：线程数 ≈ 2 * CPU核数 - CPU密集型：线程数 ≈ CPU核数 + 1 - 队列选择：有界队列防OOM --- ### 19. Java中Executor框架的使用？ **Executor 框架** 是 Java 并发编程的顶层设计，统一任务提交与执行分离。 #### 核心接口： - `Executor`：最基础，仅支持 execute(Runnable) - `ExecutorService`：扩展支持 submit(Callable)、shutdown、Future 返回 - `ScheduledExecutorService`：支持定时/周期任务 - `ThreadPoolExecutor`：具体实现类 ```java ExecutorService pool = new ThreadPoolExecutor( 2, 4, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(10), Executors.defaultThreadFactory(), new ThreadPoolExecutor.CallerRunsPolicy() ); pool.submit(() -> System.out.println("任务执行")); pool.shutdown(); ``` > ✅ 优势：解耦任务与执行策略，支持资源控制、生命周期管理 --- ### 20. Java中并发工具类的使用？ 常用并发工具类及其用途： | 工具类 | 用途 | 示例 | |-------|------|------| | `CountDownLatch` | 一个线程等待多个线程完成 | 主线程等N个下载线程结束 | | `CyclicBarrier` | 多个线程互相等待至某点再继续 | 多玩家准备就绪开始游戏 | | `Semaphore` | 控制并发访问数量（信号量） | 数据库连接池限流 | | `Exchanger` | 两个线程交换数据 | 生产者与消费者交换缓冲区 | | `Phaser`（JDK7+） | 更灵活的栅栏，支持动态注册 | 分阶段任务协调 | ```java // Semaphore 示例：限制同时访问资源的线程数 Semaphore sem = new Semaphore(3); sem.acquire(); // 获取许可 try { // 访问资源 } finally { sem.release(); // 释放许可 } ``` > ✅ 优势：简化复杂同步逻辑，提升代码可读性和可靠性 ---
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值