Java 并发工具类

JAVA面经实录9172026-05-18 8:51

第一部分：Java并发工具类生产实战代码模板

一、CountDownLatch 多任务并行汇总

业务场景

批量调用第三方接口、多线程分片查询数据、启动初始化多组件

java 复制代码 
import java.util.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CountDownLatchDemo {

    private static final ExecutorService POOL = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws InterruptedException {
        int taskNum = 5;
        CountDownLatch latch = new CountDownLatch(taskNum);

        for (int i = 0; i < taskNum; i++) {
            int idx = i;
            POOL.execute(() -> {
                try {
                    System.out.println("执行任务" + idx);
                    // 模拟业务耗时
                    Thread.sleep(500);
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    // 必须放finally，防止异常不计数
                    latch.countDown();
                }
            });
        }
        // 主线程阻塞等待全部完成
        latch.await();
        System.out.println("所有子任务执行完毕，开始汇总结果");
        POOL.shutdown();
    }
}

核心规范

  1. countDown() 强制写finally
  2. 不可重复使用，用完新建
  3. 可重载await(long timeout, TimeUnit unit)设置超时防死等

二、CyclicBarrier 线程凑齐同步执行

业务场景

批量数据同步、并发压测、多节点协同执行

java 复制代码 
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CyclicBarrierDemo {
    private static final ExecutorService POOL = Executors.newFixedThreadPool(8);

    public static void main(String[] args) {
        // 凑齐6个线程再一起执行，凑齐后执行回调
        CyclicBarrier barrier = new CyclicBarrier(6, () ->
                System.out.println("全员就位，统一开始执行任务"));

        for (int i = 0; i < 6; i++) {
            int idx = i;
            POOL.execute(() -> {
                try {
                    System.out.println("线程" + idx + "到达等待点");
                    // 等待其他线程
                    barrier.await();
                    System.out.println("线程" + idx + "正式执行业务");
                } catch (InterruptedException | BrokenBarrierException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }
        POOL.shutdown();
    }
}

特点：可循环复用；线程中断会破坏屏障

三、Semaphore 接口限流 / 资源并发控制

业务场景

第三方接口限流、数据库连接管控、单机并发数限制

java 复制代码 
import java.util.concurrent.Semaphore;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SemaphoreLimitDemo {
    // 最大允许并发10个
    private static final Semaphore SEMAPHORE = new Semaphore(10);
    private static final ExecutorService POOL = Executors.newCachedThreadPool();

    public static void main(String[] args) {
        for (int i = 0; i < 30; i++) {
            int idx = i;
            POOL.execute(() -> {
                try {
                    // 获取许可
                    SEMAPHORE.acquire();
                    System.out.println("任务" + idx + "获取许可，执行业务");
                    Thread.sleep(800);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    // 释放许可，必写finally
                    SEMAPHORE.release();
                }
            });
        }
        POOL.shutdown();
    }
}

扩展 ：tryAcquire()非阻塞获取，抢不到直接降级

四、ReentrantLock 可重入显式锁标准模板

业务场景

需要超时抢锁、可中断、公平锁、多条件等待

java 复制代码 
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.TimeUnit;

public class ReentrantLockBizDemo {
    // 非公平锁（默认）
    private static final Lock LOCK = new ReentrantLock();
    // 公平锁写法：new ReentrantLock(true)

    public void bizMethod() {
        // 1. 基础加锁写法
        LOCK.lock();
        try {
            // 临界区业务代码
            System.out.println("执行互斥业务逻辑");
        } finally {
            // 强制finally解锁，防止死锁
            LOCK.unlock();
        }
    }

    // 2. 超时抢锁（生产常用防死锁）
    public boolean tryLockBiz() {
        boolean tryGet = false;
        try {
            // 3秒内抢不到直接放弃
            tryGet = LOCK.tryLock(3, TimeUnit.SECONDS);
            if (tryGet) {
                // 执行业务
                System.out.println("抢锁成功");
            } else {
                System.out.println("抢锁超时，执行降级逻辑");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            if (tryGet) {
                LOCK.unlock();
            }
        }
        return tryGet;
    }
}

五、ReentrantReadWriteLock 读写锁模板

业务场景

本地缓存、配置数据、读多写少业务

java 复制代码 
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockCacheDemo {
    private final ReadWriteLock rwLock = new ReentrantReadWriteLock();
    private String cacheData;

    // 读操作：共享锁，多线程并发读
    public String getCache() {
        rwLock.readLock().lock();
        try {
            return cacheData;
        } finally {
            rwLock.readLock().unlock();
        }
    }

    // 写操作：排他锁，互斥执行
    public void setCache(String data) {
        rwLock.writeLock().lock();
        try {
            this.cacheData = data;
        } finally {
            rwLock.writeLock().unlock();
        }
    }
}

架构要点：支持锁降级，严禁锁升级

六、Condition 精准分组等待唤醒

业务场景

生产者消费者、队列满 / 空精准阻塞

java 复制代码 
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ConditionQueueDemo {
    private final Lock lock = new ReentrantLock();
    // 队列非空条件
    private final Condition notEmpty = lock.newCondition();
    // 队列非满条件
    private final Condition notFull = lock.newCondition();
    private int count = 0;
    private static final int MAX_SIZE = 10;

    // 生产
    public void produce() throws InterruptedException {
        lock.lock();
        try {
            while (count >= MAX_SIZE) {
                notFull.await(); // 队列满等待
            }
            count++;
            System.out.println("生产完成，数量：" + count);
            notEmpty.signal(); // 唤醒消费
        } finally {
            lock.unlock();
        }
    }

    // 消费
    public void consume() throws InterruptedException {
        lock.lock();
        try {
            while (count <= 0) {
                notEmpty.await(); // 队列为空等待
            }
            count--;
            System.out.println("消费完成，数量：" + count);
            notFull.signal(); // 唤醒生产
        } finally {
            lock.unlock();
        }
    }
}

七、ThreadLocal 上下文透传标准模板

业务场景

登录用户信息、链路追踪 ID、数据源上下文

java 复制代码 
public class UserContextHolder {
    // 全局线程本地存储
    private static final ThreadLocal<LoginUser> USER_HOLDER = new ThreadLocal<>();

    // 设置用户
    public static void setUser(LoginUser user) {
        USER_HOLDER.set(user);
    }

    // 获取用户
    public static LoginUser getUser() {
        return USER_HOLDER.get();
    }

    // 强制清空，杜绝内存泄漏
    public static void clear() {
        USER_HOLDER.remove();
    }
}

// 使用规范
class BizService {
    public void execute() {
        try {
            UserContextHolder.setUser(new LoginUser());
            // 业务全链路获取上下文
            LoginUser user = UserContextHolder.getUser();
        } finally {
            // 必清！线程池环境强制清理
            UserContextHolder.clear();
        }
    }
}

// 实体模拟
class LoginUser{}

八、高并发计数 LongAdder 模板

业务场景

接口访问量、消息统计、海量数据累加

java 复制代码 
import java.util.concurrent.atomic.LongAdder;

public class HighConcurrentCountDemo {
    // 分段累加，高并发远超AtomicLong
    private static final LongAdder COUNT = new LongAdder();

    // 自增
    public static void incr() {
        COUNT.increment();
    }

    // 获取总数
    public static long getTotal() {
        return COUNT.sum();
    }
}

九、CompletableFuture 异步编排生产模板

业务场景

微服务接口聚合、多接口并行调用

java 复制代码 
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

public class CompletableFutureBizDemo {

    // 并行执行多个任务
    public static CompletableFuture<Void> batchTask() {
        CompletableFuture<String> task1 = CompletableFuture.supplyAsync(() -> {
            TimeUnit.MILLISECONDS.sleep(300);
            return "接口1结果";
        });

        CompletableFuture<String> task2 = CompletableFuture.supplyAsync(() -> {
            TimeUnit.MILLISECONDS.sleep(500);
            return "接口2结果";
        });

        // 全部执行完成再汇总
        return CompletableFuture.allOf(task1, task2)
                .whenComplete((unused, throwable) -> {
                    if (throwable != null) {
                        // 全局异常捕获
                        throwable.printStackTrace();
                    }
                });
    }

    public static void main(String[] args) throws Exception {
        batchTask().join();
        System.out.println("所有异步任务执行完成");
    }
}

十、自定义线程池 + 自定义拒绝策略 完整投产模板

java 复制代码 
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import java.util.concurrent.*;

/**
 * 业务专用线程池 生产模板
 */
public class BizThreadPool {
    // 核心线程
    private static final int CORE = 8;
    // 最大线程
    private static final int MAX = 16;
    // 空闲销毁时间
    private static final long ALIVE_TIME = 60L;
    // 有界队列容量
    private static final int QUEUE_SIZE = 200;

    // 自定义线程工厂，命名方便排查
    private static final ThreadFactory THREAD_FACTORY = new ThreadFactoryBuilder()
            .setNameFormat("biz-execute-pool-%d")
            .setDaemon(false)
            .build();

    // 自定义拒绝策略
    private static class CustomRejectHandler implements RejectedExecutionHandler {
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            // 日志告警
            System.err.println("业务线程池已满，触发自定义降级策略");
            // 方案：交由调用者执行，平稳降级
            new Thread(r).start();
        }
    }

    // 单例线程池
    private static final ThreadPoolExecutor BIZ_POOL = new ThreadPoolExecutor(
            CORE,
            MAX,
            ALIVE_TIME,
            TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(QUEUE_SIZE),
            THREAD_FACTORY,
            new CustomRejectHandler()
    );

    // 对外提交任务
    public static void execute(Runnable task) {
        BIZ_POOL.execute(task);
    }

    // 获取线程池
    public static ThreadPoolExecutor getPool() {
        return BIZ_POOL;
    }
}

十一、并发容器实战选用速记

java 复制代码 
// 1. 高并发键值存储
ConcurrentHashMap<String, Object> map = new ConcurrentHashMap<>();

// 2. 读多写少集合
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();

// 3. 阻塞队列 生产者消费者
BlockingQueue<String> queue = new ArrayBlockingQueue<>(500);

十二、生产通用并发编码规范

  1. 所有锁释放、计数释放、上下文清除一律写 finally
  2. 业务禁止使用Executors快捷创建线程池
  3. 并发计数高并发优先LongAdder，普通场景AtomicLong
  4. 线程池内任务严禁使用ThreadLocal不清理
  5. 同步工具类尽量设置超时时间，防止无限阻塞
  6. 读写锁严格区分读写场景，最大化并发性能

第二部分：Java并发全家桶

一、核心底层基石

  1. volatile 可见性、禁指令重排、不保证原子性；用于状态标记、双重校验锁
  2. CAS乐观锁无锁操作，自旋比较交换；缺点：ABA、自旋消耗、只能单变量
  3. AQS 队列同步器，state状态 + CLH 双向队列 + LockSupport 阻塞唤醒
  • 独占：ReentrantLock
  • 共享：CountDownLatch/Semaphore

二、三大同步计数器（AQS 共享）

  1. CountDownLatch 倒计时递减，一次性不可复用 ；主线程等多子线程完成核心：countDown()、await()
  2. CyclicBarrier 凑齐指定线程一起执行，可循环复用 ；并发压测、批量同步核心：await()
  3. Semaphore 信号量限流，控制最大并发数；接口限流、资源配额核心：acquire()、release()

三、显式锁体系

  1. ReentrantLock 可重入独占锁，支持公平 / 非公平、超时抢锁、可中断规范：lock() try finally unlock()
  2. ReentrantReadWriteLock 读写分离：读读共享、读写 / 写写互斥；读多写少缓存场景支持锁降级，不支持锁升级
  3. StampedLockJDK8 高性能读写锁，乐观读无阻塞，杜绝线程饥饿
  4. Condition Lock 专属等待唤醒，多条件队列精准分组唤醒，替代 wait/notify

四、线程本地上下文

ThreadLocal 线程私有数据隔离，存用户登录态、链路 ID底层：Thread→ThreadLocalMap→Entry (key 弱引用，value 强引用)坑：线程池引发内存泄漏 ，用完必须remove()衍生：InheritableThreadLocal 父子线程传值

五、原子无锁类

  1. 基础原子：AtomicInteger、AtomicLong
  2. 高并发计数：LongAdder（分段求和，性能远超 Atomic）
  3. 引用原子：AtomicReference
  4. 解决 ABA：AtomicStampedReference

六、线程池体系

  1. 七大参数：核心线程、最大线程、空闲时长、时间单位、阻塞队列、线程工厂、拒绝策略
  2. 执行流程：核心满→入队列→队列满→开非核心→满则拒绝
  3. 常用队列ArrayBlockingQueue (有界推荐)、LinkedBlockingQueue、SynchronousQueue、DelayQueue
  4. 四大拒绝策略Abort 抛异常、CallerRuns 主线程执行、Discard 丢弃、DiscardOldest 丢队首
  5. 状态：RUNNING→SHUTDOWN→STOP→TIDYING→TERMINATED
  6. 规范：禁止 Executors，手动创建 ThreadPoolExecutor，自定义线程名

七、并发容器

  1. ConcurrentHashMapJDK1.7 分段锁、1.8 CAS+synchronized；高并发 KV 首选
  2. CopyOnWriteArrayList 写时复制，读无锁；读多写少专用
  3. 阻塞队列 BlockingQueue生产者消费者、线程池内核、消息缓冲

八、异步线程编排

CompletableFutureJDK8 最强异步工具allOf/anyOf 多任务组合、回调处理、异常捕获、接口并行聚合

九、线程通信与阻塞唤醒

  1. wait/notify：synchronized 配套，随机唤醒
  2. LockSupport：park/unpark，无锁阻塞，AQS 底层依赖
  3. Condition：精准唤醒

十、死锁核心

  1. 四大条件：互斥、请求持有、不可剥夺、循环等待
  2. 规避：统一加锁顺序、超时锁、缩小锁范围、减少嵌套
  3. 排查：jps+jstack

十一、线程六大状态

新建→就绪→运行→阻塞 BLOCKED→等待 WAITING→超时等待 TIMED_WAITING→终止

十二、场景极速选型

  1. 多任务汇总 → CountDownLatch
  2. 多线程同步起跑 → CyclicBarrier
  3. 接口限流控并发 → Semaphore
  4. 灵活可中断锁 → ReentrantLock
  5. 读多写少缓存 → 读写锁
  6. 线程上下文透传 → ThreadLocal
  7. 高并发统计计数 → LongAdder
  8. 并行接口调用 → CompletableFuture
  9. 高并发键值缓存 → ConcurrentHashMap
  10. 读多写少集合 → CopyOnWriteArrayList
  11. 任务队列削峰 → 阻塞队列
  12. 定时延时任务 → Scheduled 线程池 / DelayQueue

十三、并发避坑一句话

  1. 锁必放 finally 释放
  2. ThreadLocal 用完必清空
  3. 线程池务必用有界队列
  4. 高并发计数优先 LongAdder
  5. 多锁统一顺序防死锁
  6. 异步任务必须捕获异常
  7. 共享资源优先无锁 / 并发容器，少手写同步
相关推荐
189228048611 小时前
NV266固态MT29F32T08GSLBHL8-36QMES:B
大数据·服务器·人工智能·科技·缓存
吃好睡好便好1 小时前
在Matlab中绘制变半径柱面图
开发语言·人工智能·学习·算法·matlab
驭渊的小故事1 小时前
Java数据结构集合框架（顺序表(ArrayList)的详细解析）（两千字详细解析）
java·开发语言
hanbr1 小时前
Qt：事件处理与绘图详解
开发语言·数据库·qt
AI周红伟1 小时前
Token工厂，华为，阿里，抖音，百度，入局造Token，特朗普，买入英伟达、苹果、英特尔 ，算力工厂
大数据·人工智能·windows·百度·copilot
luck_bor1 小时前
File 类核心笔记
java·前端·算法
ZC跨境爬虫1 小时前
模块化烹饪小程序开发日记 Day2：全局配置与 tabBar 实现
java·前端·javascript·微信小程序·html·notepad++
cen__y1 小时前
Linux知识点复习总结(2)
linux·运维·服务器·c语言·开发语言
方便面不加香菜1 小时前
C++ 日期类的实现
开发语言·c++
热门推荐
01GitHub 镜像站点02Codex 接入 DeepSeek API 完整配置文档03【AI】2026 年具身智能模型和世界模型总结04Gemini大升级、AI眼镜首发、Android XR亮相，13天后见分晓05人工智能最新动态 AI 日报 · 2026年5月10日06Codex 手机端连接教程：三分钟搞定，附完整步骤07CC-Switch & Claude 基于 Linux 服务器安装使用指南082026年AI前瞻：量子AI、具身智能与科学发现的新纪元09裂开！ChatGPT 居然开始要手机号验证，附详细解决方法10几个好用的ip纯净度检测网站