Lycka

外观

阶段一：线程基础能力

约 9577 字大约 32 分钟

2026-03-19

学习重点：学习线程本身。

重要

start()：真正开启新线程，由 JVM 执行 run() 方法。

run()：一个普通方法。

join()：等待子线程执行完毕。

判断线程的基本状态

Thread t = new Thread(() -> {});
System.out.println(t.getState()); // NEW
t.start();
System.out.println(t.getState()); // RUNNABLE 或 TIMED_WAITING 等

线程的三种创建方式

方式 1：继承 Thread

class Thread1 extends Thread {
    @Override
    public void run() {
        System.out.println("==thread2 is running");
        for (int i = 0; i < 5; i++) {
            System.out.println("==thread2:" + i);
        }
    }
}

方式 2：实现 Runnable 接口

class Thread2 implements Runnable {
    @Override
    public void run() {
        System.out.println("--thread1 is running");
        for (int i = 0; i < 5; i++) {
            System.out.println("--thread1:" + i);
        }
    }
}

方式 3: FeatureTask + Callable

class Thread3 implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "~~thread3 is running";
    }
}

public class BasicThread {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String> futureTask = new FutureTask<>(new Thread3());
        Thread t3 = new Thread(futureTask);

        t3.start();
        String result = futureTask.get();
        System.out.println(result);
    }
}

线程同步与通信

提示

wait()、notify() 等方法由 Object 提供。

线程同步的几种常见场景

场景建议做法
多线程累加变量synchronized、Lock、AtomicInteger
多线程读写共享集合Collections.synchronizedList、ConcurrentHashMap
需要等待某个条件wait/notify、CountDownLatch、Condition

线程同步和通信包含两组工具

  • wait() / notify() + synchronied
  • ReentrantLock + Condition

synchronized 关键字（内置锁）

用法 1：作用于实例方法，锁的是当前对象

public synchronized void increment() {
    count++;
}

// 等价于
public void increment() {
    synchronized(this) {
        count++;
    }
}

用法 2：作用于静态方法

public static synchronized void increment() {
    // 锁的是 Class 对象（Counter.class）
}

用法 3：作用于代码块

public void increment() {
    synchronized(someObject) {
        count++;
    }
}

对象锁 vs 类锁

  • 对象锁：锁住的是某个实例（this 或其他对象）
  • 类锁：锁住的是类的 .class 对象

多个线程使用不同对象调用同步方法时，对象锁是互不干扰的

案例：多个线程累加同一个变量

wait() / notify() + synchronized

方法含义
wait()当前线程进入等待状态，释放锁，等待被唤醒
notify()唤醒一个正在等待的线程（不会立即释放锁）
notifyAll()唤醒所有等待线程

提示

这些方法都是 Object 类定义的，意味着每个对象都可以作为“锁”和“通信器”。

等待通知案例

重要

  1. wait() / notify() 必须在同步块中使用（即 synchronized(lock)）。
  2. wait() 会释放锁，notify() 不会释放锁。
  3. 搭配 while 循环判断条件，避免“假唤醒”。

✅ 实战用途

  • 线程协作（如：生产者-消费者模型）。
  • 等待条件达成（比如任务就绪、队列不空）。
  • 手写线程池或锁时会用到它们。

常见疑问

Q： 为什么推荐用 while (条件不满足) wait() 而不是 if？

A：防止“虚假唤醒”（Spurious Wakeup）

错误写法
synchronized (lock) {
    if (!ready) {
        lock.wait(); // 一旦被“错误地唤醒”，就跳过这一步了
    }
    // 然后这里就执行了，尽管 ready 可能仍然是 false！
}

如果用 if，只判断一次，被唤醒后不再检查条件，就可能出现逻辑错误。

正确写法
synchronized (lock) {
    while (!ready) {
        lock.wait(); // 被唤醒之后再次判断条件
    }
    // 条件真的满足后再继续执行
}

这叫 “条件等待 + 状态检查”，是 wait-notify 模型的标准写法。

Q：Spurious Wakeup 是什么？

A：Java 虚拟机规范允许线程在 没有被 notify() 的情况下也可能被唤醒，这是“虚假唤醒”。虽然在绝大多数情况下不会出现，但 JVM 的文档要求开发者必须写 while，因为它无法保证永远不发生。

volatile 关键字

volatile 是 Java 的一个轻量级同步机制，作用是保证 变量在多个线程间的可见性。

没有使用 volatile 的案例
public class Demo {
    static boolean flag = false;

    public static void main(String[] args) throws Exception {
        new Thread(() -> {
            while (!flag) {
                // 可能会死循环
            }
            System.out.println("flag changed");
        }).start();

        Thread.sleep(1000);
        flag = true;
    }
}

这段代码理论上会输出 flag changed，但有时候不会。

原因：主线程改了 flag 为 true，但子线程可能缓存了 flag = false 的旧值 ，所以看不到主线程的改动

修复代码
static volatile boolean flag = false;

这表示：每次读写都直接从主内存中读取/写入，不使用线程缓存。

ReentrantLock 可重入锁 + Condition

虽然 synchronized 简单好用，但它有以下局限性：

功能需求synchronizedReentrantLock
可中断锁获取❌ 不支持✅ 支持
尝试加锁（带超时）❌ 不支持✅ 支持
公平锁❌ 不支持✅ 支持
多条件变量❌ 不支持✅ 支持
更灵活的释放控制❌ 自动释放✅ 手动释放

所以，当需要更复杂的控制逻辑或高并发优化时，ReentrantLock 是首选。

基本使用方法
import java.util.concurrent.locks.ReentrantLock;

public class LockExample {
    private final ReentrantLock lock = new ReentrantLock();
    private int count = 0;

    public void increment() {
        lock.lock(); // 加锁
        try {
            count++;
        } finally {
            lock.unlock(); // 一定要释放锁（防止死锁）
        }
    }
}

提示

ReentrantLock 和 synchronized 的简要区别

  • lock() 不会自动释放锁，必须在 finally 中调用 unlock()
  • 如果 lock() 多次，必须 unlock() 同样多次（可重入）

⚙️ tryLock()：尝试加锁

可以防止阻塞，做失败快速返回的处理。

if (lock.tryLock()) {
    try {
        // 获取到了锁，安全操作
    } finally {
        lock.unlock();
    }
} else {
    // 没获取到锁，做其他事
}

🕰️ tryLock(timeout, unit)：限时尝试加锁

适合高并发限流场景，比如控制同时访问资源的人数。

if (lock.tryLock(1, TimeUnit.SECONDS)) {
    try {
        // 成功获取锁
    } finally {
        lock.unlock();
    }
} else {
    // 一秒内没抢到锁
}

⚖️ 公平锁（Fair Lock）

  • 公平锁：先来先得
  • 非公平锁（默认）：性能更好，但可能有“插队”
ReentrantLock lock = new ReentrantLock(true); // true 表示公平锁

配套工具：Condition

如果说 synchronized + wait/notify 是配套的，那 ReentrantLock 的配套就是 Condition。

创建方式
ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();
方法含义
await()等待，释放锁
signal()唤醒一个线程
signalAll()唤醒所有线程

示例：ReentrantLock + Condition 实现线程等待通知

提示

Condition 是可以创建多个的，当有三个线程顺序执行的时候

可以创建多个 condition:

Condition conditionA = lock.newCondition();
Condition conditionB = lock.newCondition();
Condition conditionC = lock.newCondition();

逻辑结构如下：

Thread A：await on conditionA → print A → signal conditionB

Thread B：await on conditionB → print B → signal conditionC

Thread C：await on conditionC → print C → signal conditionA

特性synchronizedReentrantLock
是否自动释放✅❌ 必须手动释放
是否支持 tryLock❌✅
条件变量❌ 只能一个（object）✅ 多个 Condition
公平性控制❌✅
是否可中断获取❌✅

原子类(Atomic): 无锁编程利器

在多线程环境下，如果多个线程并发更新共享变量（如一个计数器），就必须使用同步手段防止竞态。之前我们用的是：

  • synchronized（重量级）
  • ReentrantLock（灵活，但也需要手动加解锁）

但有时候，我们只是对一个数值做简单的加减操作，如果用锁未免太重了。

✅ 解决方案：原子类 = 轻量级线程安全操作，利用底层的 CAS（Compare-And-Swap）机制，避免加锁，提高性能。

常见原子类（位于 java.util.concurrent.atomic 包）

类名功能
AtomicInteger原子整型
AtomicLong原子长整型
AtomicBoolean原子布尔值
AtomicReference<T>原子引用类型

AtomicInteger 使用示例

常用方法一览（以 AtomicInteger 为例）

方法含义
get()获取当前值
set(x)设置为指定值
incrementAndGet()加一并返回新值
getAndIncrement()返回旧值再加一
decrementAndGet()减一并返回
getAndSet(x)设置新值并返回旧值
compareAndSet(expect, update)如果当前值等于 expect，就设置为 update（CAS）

警告

  1. 原子类只能保证一个变量的操作是线程安全的
  2. 若多个变量有关联逻辑（如账户转账），仍需要锁机制
  3. 和锁比：性能更高、开销更小、但功能也更有限

Atomic vs synchronized

特点AtomicIntegersynchronized
是否加锁❌ 无锁（CAS）✅
是否阻塞❌✅
粒度单变量任意代码块
性能高视并发量而定
适合场景高并发计数器、状态标志等复杂业务逻辑、多变量控制

总结一句话

如果你只是在并发环境下对一个数值进行 加减、设置、比较替换等简单操作，首选 AtomicXXX 类。

ThewadLocal

ThreadLocal 提供了线程本地变量，每个线程访问它时，获取的都是自己专属的副本，互不干扰。 它可以让多个线程在不加锁的情况下，各自拥有独立的变量值。

为什么需要它？

在多线程环境中，如果多个线程操作同一个变量，要么：

  • 加锁（性能损耗）
  • 拷贝副本（麻烦）

而 ThreadLocal 可以完美解决这个问题。

简单示例
public class ThreadLocalExample {

    private static final ThreadLocal<String> local = new ThreadLocal<>();

    public static void main(String[] args) {
        Runnable task = () -> {
            String threadName = Thread.currentThread().getName();
            local.set(threadName + " 的数据");
            System.out.println(threadName + " 获取：" + local.get());
        };

        Thread t1 = new Thread(task, "线程A");
        Thread t2 = new Thread(task, "线程B");

        t1.start();
        t2.start();
    }
}

常用方法

方法说明
set(T value)设置当前线程的值
get()获取当前线程的值
remove()清除当前线程的值（防止内存泄漏）
initialValue()可通过继承 ThreadLocal 并重写该方法设置默认值

使用场景举例

  1. 用户登录上下文信息（当前用户 ID）
  2. 数据库连接对象
  3. 日志追踪 ID（链路追踪）
  4. Spring 中的 RequestContextHolder（Web 请求线程隔离）

重要

内存泄漏风险（重点）

  • ThreadLocal 实际是绑定在线程对象里的 Map 中（ThreadLocalMap）
  • 如果线程是线程池里的（如 Tomcat、线程池复用），线程不会销毁
  • 不调用 remove() 可能导致内存泄漏
正确使用姿势
try {
   local.set("some data");
   // 使用
} finally {
   local.remove(); // 必须清理
}

提示

内存泄露（Memory Leak）：内存被占用，但是无法被回收。Leak 是比喻泼出去的水，无法再拿回来。

内存溢出（Memory Overflow）：内存不够直接撑爆了。

总结

特点内容
作用线程私有变量
是否线程安全✅（天生安全）
是否共享数据❌ 每个线程独立
使用建议有设置就要有 remove

并发容器（ConcurrentHashMap、BlockingQueue 等）

这些数据结构是支持高并发读写且无需手动加锁的神器。

在多线程环境下，常规的集合类（如 ArrayList、HashMap、HashSet）是非线程安全的：

  • 并发修改时可能导致数据损坏（如死循环、元素丢失）
  • 手动加锁麻烦且容易出错

Java 为了解决这个问题，提供了 高性能、线程安全的并发集合类。

常见并发容器对比表

容器描述适用场景
ConcurrentHashMap线程安全的哈希表替代 HashMap
CopyOnWriteArrayList读写分离列表多读少写的列表
BlockingQueue阻塞队列生产者-消费者模型
ConcurrentLinkedQueue非阻塞链表队列高性能队列
ConcurrentSkipListMap有序Map，基于跳表替代 TreeMap

ConcurrentHashMap（最常用）

支持高并发读写，内部采用分段锁（早期）+ CAS 机制实现。

用法案例
import java.util.concurrent.ConcurrentHashMap;

public class CHMExample {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

        map.put("A", 1);
        map.put("B", 2);
        map.compute("A", (k, v) -> v + 1); // 原子更新

        System.out.println(map); // 输出：{A=2, B=2}
    }
}

CopyOnWriteArrayList（多读少写）

✅ 适合“读远大于写”的场景，如系统配置、白名单等。

❗ 缺点：每次写操作都会 复制整个数组，写多了性能差。

用法案例
import java.util.concurrent.CopyOnWriteArrayList;

public class COWExample {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        list.add("Java");
        list.add("Python");

        for (String item : list) {
            list.add("Go"); // 允许边遍历边修改，不抛异常
        }

        System.out.println(list); // 输出所有元素
    }
}

BlockingQueue（支持阻塞等待）

接口：BlockingQueue<E>

常用实现：

  • ArrayBlockingQueue（有界）
  • LinkedBlockingQueue（无界）
  • DelayQueue（带延迟）
  • PriorityBlockingQueue（优先级队列）
案例

✅ 这是多线程通信中最常用的队列形式，可以轻松实现线程解耦、异步任务处理。

总结

容器特点场景推荐
ConcurrentHashMap高并发读写，不需要锁替代 HashMap
CopyOnWriteArrayList写时复制，线程安全多读少写
BlockingQueue支持阻塞 put/take生产者-消费者
ConcurrentLinkedQueue非阻塞队列高性能无界队列
ConcurrentSkipListMap有序线程安全 Map高并发排序结构

JUC 并发控制工具类

Java 提供了一批位于 java.util.concurrent 包下的 线程协调工具类，它们不是“锁”，但可以让多个线程协作完成任务。

工具类功能简介
CountDownLatch倒计时锁，等待一组线程完成
CyclicBarrier回环屏障，等待一组线程到达统一点
Semaphore信号量，限流控制

CountDownLatch - 等待多个线程完成

✅ 核心概念：

  • 一开始设置一个计数值（例如 3）
  • 每个线程完成后调用 countDown()，计数器减一
  • 主线程调用 await() 会一直阻塞，直到计数为 0

🧠 应用场景：

  • 主线程等待多个子任务初始化完成后再执行
  • 多线程批处理
案例 1
案例 2

CyclicBarrier - 等待彼此都到齐

✅ 核心概念：

  • 一组线程互相等待，直到“全部到齐”
  • 到齐后统一继续执行
  • 可以 循环使用

🧠 应用场景：

  • 多个线程并行准备、统一执行
  • 分阶段执行任务（如地图加载 + UI 渲染）
案例 1
案例 2
输出示例（可能不同，每次线程调度不一样）
任务A：执行第一阶段工作
任务B：执行第一阶段工作
任务C：执行第一阶段工作
任务B：第一阶段完成，等待其他任务
任务A：第一阶段完成，等待其他任务
任务C：第一阶段完成，等待其他任务
=== 所有子任务到达屏障点，进入下一阶段 ===
任务A：执行第二阶段工作
任务B：执行第二阶段工作
任务C：执行第二阶段工作
任务A：第二阶段完成，等待其他任务
任务B：第二阶段完成，等待其他任务
任务C：第二阶段完成，等待其他任务
=== 所有子任务到达屏障点，进入下一阶段 ===
任务A：所有阶段完成，结束
任务B：所有阶段完成，结束
任务C：所有阶段完成，结束

Semaphore - 控制并发线程数

✅ 核心概念：

  • 类似限流器
  • 控制同时运行的线程数量
  • 超过限制会阻塞，直到有线程释放许可

🧠 应用场景：

  • 接口限流、并发控制
  • 数据库连接池最大连接数
  • 控制最多几个用户同时登录等
案例 1
案例 2

总结：三种工具类对比

工具类用法场景是否可复用核心方法
CountDownLatch等待多个线程完成❌ 不可重置countDown() / await()
CyclicBarrier一组线程集合后一起执行✅ 可重置await()
Semaphore控制资源数量/并发限流✅ 可复用acquire() / release()

线程池（ExecutorService & ThreadPoolExecutor）

几乎所有实际项目中都用线程池来执行任务，尤其在：

  • 接口异步处理
  • 消息消费
  • 定时任务调度
  • 后台计算任务

等场景中，是性能、稳定性和扩展性的关键保障。

需要线程池的原因

如果每次执行任务都 new Thread()：

❌ 缺点：

  • 每次都创建线程，开销大
  • 无法管理线程的数量和生命周期
  • 无法复用线程、易OOM或线程过多
  • 不利于排查问题

✅ 使用线程池好处：

  • 控制最大并发数，防止系统资源耗尽
  • 线程复用，避免频繁创建销毁
  • 支持任务排队与调度
  • 提供统一的生命周期管理、拒绝策略、异常处理机制

线程池核心接口：ExecutorService

ExecutorService executor = Executors.newFixedThreadPool(4);

executor.submit(() -> {
    // 执行任务
});
executor.shutdown();

这是最常用的线程池接口，支持：

  • 提交任务
  • 获取执行结果（Future）
  • 优雅关闭线程池（shutdown()）

四种常见线程池创建方式（Executors 工具类）

Executors.newFixedThreadPool(n);     // 固定大小线程池
Executors.newCachedThreadPool();     // 自动扩容线程池
Executors.newSingleThreadExecutor(); // 单线程池
Executors.newScheduledThreadPool(n); // 定时任务线程池

🔥 推荐使用自定义 ThreadPoolExecutor

构造方法
public ThreadPoolExecutor(
    int corePoolSize,      // 核心线程数
    int maximumPoolSize,   // 最大线程数
    long keepAliveTime,    // 非核心线程最大空闲时间
    TimeUnit unit,         // 时间单位
    BlockingQueue<Runnable> workQueue,  // 任务队列
    ThreadFactory threadFactory,        // 线程工厂（可选）
    RejectedExecutionHandler handler    // 拒绝策略
)

笔记

面试中经常会问这几个参数。

案例
import java.util.concurrent.*;

public class CustomThreadPool {
    public static void main(String[] args) {
        ExecutorService pool = new ThreadPoolExecutor(
            2,                    // 核心线程数
            4,                    // 最大线程数
            60, TimeUnit.SECONDS,// 非核心线程存活时间
            new LinkedBlockingQueue<>(10), // 等待队列
            Executors.defaultThreadFactory(), // 线程工厂
            new ThreadPoolExecutor.AbortPolicy() // 拒绝策略
        );

        for (int i = 0; i < 15; i++) {
            final int taskId = i;
            pool.execute(() -> {
                System.out.println(Thread.currentThread().getName() + " 执行任务 " + taskId);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException ignored) {}
            });
        }

        pool.shutdown();
    }
}

线程池中任务的排队与调度机制

三类任务提交过程：

  1. 核心线程未满 ➜ 新建线程处理任务
  2. 核心线程满，队列未满 ➜ 任务加入队列等待
  3. 队列满，线程数量未达最大 ➜ 创建非核心线程处理任务
  4. 队列满，线程满 ➜ 启动拒绝策略

拒绝策略（RejectedExecutionHandler）

策略描述
AbortPolicy默认，抛异常（推荐）
CallerRunsPolicy任务回退给提交线程
DiscardPolicy直接丢弃任务
DiscardOldestPolicy丢弃最早的队列任务，尝试执行当前任务

线程池参数推荐配置(参考)

项推荐值说明
核心线程数CPU 核心数，如 Runtime.getRuntime().availableProcessors()
最大线程数视业务复杂度而定（建议为核心线程数的 2~4 倍）
队列大小看任务堆积容忍度，太大会导致内存撑爆
拒绝策略推荐用 AbortPolicy 配合日志或监控告警

总结：要牢记的线程池核心点

关键项说明
线程池入口ExecutorService
推荐方式自定义 ThreadPoolExecutor
拒绝策略一定要了解，避免任务悄悄丢失
线程复用节省资源、提升性能
shutdown及时关闭线程池，释放资源

线程池中的异步任务与 Future

什么是 Future

Future 表示一个可能还未完成的异步任务的结果，你可以：

  • 提交一个任务，让它在线程池中运行
  • 后续通过 Future.get() 获取结果（同步阻塞）
  • 或者判断是否完成 / 取消任务

基础示例：submit + Future

import java.util.concurrent.*;

public class FutureExample {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newFixedThreadPool(2);

        Future<Integer> future = executor.submit(() -> {
            Thread.sleep(1000);
            return 42;
        });

        System.out.println("任务已提交，主线程可以做点别的事...");

        // 阻塞等待结果
        Integer result = future.get();
        System.out.println("任务结果: " + result);

        executor.shutdown();
    }
}

// 输出
// 任务已提交，主线程可以做点别的事...
// 任务结果: 42

Future.get() 是阻塞的！

future.get(); // 会一直等，直到任务完成

// 可以使用超时控制：
future.get(2, TimeUnit.SECONDS); // 最多等 2 秒

局限性

Future 虽然可以获取结果，但它：

  • ❌ 不支持任务完成后的自动回调
  • ❌ 不支持链式任务（一个任务依赖另一个任务结果）
  • ❌ 代码写起来容易阻塞、嵌套复杂

升级! CompletableFuture（JDK 8+）

CompletableFuture 是 Java8 引入的强大工具，支持：

特性说明
非阻塞回调支持任务完成后自动执行回调
异步执行提交任务后不阻塞主线程
链式调用支持多个任务组合、依赖
异常处理支持 exceptionally() 捕获异常

示例 1：异步执行 + 回调

import java.util.concurrent.CompletableFuture;

public class CFExample1 {
    public static void main(String[] args) {
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            try {
                Thread.sleep(1000);
                System.out.println("任务完成！");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        System.out.println("主线程继续执行");

        future.join(); // 等待结束（非必须）
    }
}

有返回值 + thenApply 链式处理

import java.util.concurrent.CompletableFuture;

public class CFExample2 {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            return 10;
        }).thenApply(value -> {
            return value * 2;
        });

        System.out.println("结果是：" + future.join()); // 输出 20
    }
}

异常处理（exceptionally）

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    if (true) throw new RuntimeException("出错了！");
    return 1;
}).exceptionally(e -> {
    System.out.println("捕获异常：" + e.getMessage());
    return -1;
});

System.out.println("结果是：" + future.join()); // 输出 -1

CompletableFuture 核心方法一览

方法说明
runAsync(Runnable)无返回值的异步任务
supplyAsync(Supplier<T>)有返回值的异步任务
thenApply(fn)对返回值做处理
thenAccept(fn)消费返回值，无返回
thenRun(fn)不关心结果，只执行
thenCombine(f1, f2)组合两个任务的结果
exceptionally(fn)异常恢复
whenComplete(fn)无论成功或失败都执行

总结：线程池异步编程核心对比

工具特性适合场景
Future简单异步，阻塞获取结果异步任务提交
CompletableFuture非阻塞、回调、组合任务复杂异步流程

💪 实战应用场景

  • 并行远程调用多个服务（提升响应速度）
  • 数据预处理 + UI 渲染
  • 异步计算 + 回调通知
  • 多任务合并处理、聚合数据

Q&A：FutureTask vs Future 的关系

一、类关系

这是 FutureTask

public class FutureTask<V> implements RunnableFuture<V>

而 RunnableFuture 是一个接口，继承了 Runnable 和 Future：

public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

结论：

FutureTask 是一个类，实现了 Future 接口，也实现了 Runnable 接口。

这意味着：

  • 它可以被提交到线程池中执行（因为是 Runnable）
  • 它也可以作为 Future 来获取异步结果

二、使用场景

你想自己控制异步任务的启动（不依赖线程池），就使用 FutureTask。

案例
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class FutureTaskExample {
    public static void main(String[] args) throws Exception {
        Callable<Integer> task = () -> {
            Thread.sleep(1000);
            return 100;
        };

        FutureTask<Integer> futureTask = new FutureTask<>(task);

        Thread thread = new Thread(futureTask);
        thread.start();

        System.out.println("主线程继续干活...");
        Integer result = futureTask.get(); // 阻塞等待
        System.out.println("结果是：" + result);
    }
}

三、和 ExecutorService.submit(Callable) 的对比

特性FutureTasksubmit(Callable)
是否线程池依赖❌（可单独启动线程）✅
是否实现 Future✅✅
是否支持取消✅✅
使用复杂度稍复杂简单
可复用性✅（可以复用 task 对象）❌（一次性提交）

四、总结

一句话：FutureTask = 既是一个任务，又是一个结果容器，属于 Future 的具体实现。

你可以用它直接结合线程（new Thread(futureTask)），也可以作为 Runnable 被线程池执行。

🎯 实用建议

  • ✅ 简单异步任务：用 submit() 返回 Future
  • ✅ 想自己掌控线程生命周期：用 FutureTask + Callable
  • ✅ 更复杂的链式异步：用 CompletableFuture

线程基础总结

一、线程创建方式

方法特点场景示例
继承 Thread简单直观，不推荐复用学习阶段、小型测试
实现 Runnable更灵活，适合线程池批量任务处理、日志异步写入
实现 Callable + FutureTask有返回值，可结合线程池计算型任务：分页查询结果、文件分析
线程池（ExecutorService）线程复用，统一管理99% 实战任务处理选择
CompletableFuture链式、异步、回调并行请求、任务编排、聚合数据

二、线程同步与并发控制

工具特点抽象场景具体案例
synchronized内置锁，代码简洁临界区控制银行转账、票务系统
ReentrantLock显式加锁，可中断/尝试锁更灵活的资源保护并发写数据库，分布式锁封装
wait/notify线程通信等待某条件成立缓冲区满/空、单生产者消费者
Condition精准通知多条件同步线程 A 唤醒线程 B
AtomicInteger无锁计数高并发计数器网站访问量、点赞数

三、线程间数据隔离

工具特点抽象场景具体案例
ThreadLocal每个线程私有数据请求上下文隔离登录用户信息、Trace ID 传递
InheritableThreadLocal子线程继承父线程上下文多线程传递用户上下文Spring Web + 异步任务共享用户信息

四、并发容器

容器特点抽象场景具体案例
ConcurrentHashMap并发读写安全多线程共享缓存配置表、字典表缓存
CopyOnWriteArrayList多读少写安全读远大于写白名单列表、系统开关配置
BlockingQueue阻塞式队列线程间通信生产者-消费者、任务分发

五、并发控制工具类（协调多个线程）

工具类特点抽象场景具体案例
CountDownLatch一组线程倒计时等待多个任务完成多个微服务启动后主程序执行
CyclicBarrier所有线程同步起步统一执行点多人游戏准备阶段、分布式计算
Semaphore资源配额控制并发限流同时只能处理 10 个请求、连接池控制

六、线程池（统一调度任务）

类型特点抽象场景具体案例
FixedThreadPool固定线程数控制并发强度网络爬虫、数据抓取
CachedThreadPool动态线程数短生命周期大量任务日志异步写入
SingleThreadExecutor顺序执行任务保证串行逻辑日志归档、定时备份
ScheduledThreadPool定时任务周期任务健康检查、定时推送
自定义 ThreadPoolExecutor完全掌控线程行为生产级系统核心RocketMQ 消费线程池、业务服务线程隔离

七、异步任务处理与编排

工具特点抽象场景具体案例
Future同步获取结果提交任务 + 获取结果图像处理、统计任务
CompletableFuture异步回调 + 组合任务并发任务聚合、链式处理并行远程调用 + 聚合响应、AI 模型预测结果合并

八、学习建议总结：如何选择合适的线程技术？

你要实现什么？使用方案
执行异步任务ExecutorService
获取异步任务结果Future / FutureTask / CompletableFuture
控制并发数量Semaphore / 线程池
多线程间协调等待CountDownLatch / CyclicBarrier
多线程共享安全集合ConcurrentHashMap, BlockingQueue
多线程计数AtomicInteger
实现高性能限流自定义线程池 + Semaphore
多线程数据隔离ThreadLocal

知识图谱结构

---
markmap:
  colorFreezeLevel: 2
---

# 线程基础

## 线程同步

- synchronized
- ReentrantLock
- wait/notify
- AtomicXXX

## 线程通信

- BlockingQueue
- CountDownLatch
- CyclicBarrier
- Semaphore

## 线程隔离

- ThreadLocal

## 并发容器

- ConcurrentHashMap
- CopyOnWriteArrayList

## 线程池

- Executors
- ThreadPoolExecutor
- Future / FutureTask
- CompletableFuture

实战案例

难度任务描述
⭐ 简单三个线程按顺序打印 A-B-C
⭐⭐ 中等两个线程交替打印奇偶数
⭐⭐⭐ 进阶使用线程池并发执行任务，收集返回结果
⭐⭐⭐⭐ 挑战实现生产者-消费者模型（BlockingQueue + 多线程）
⭐⭐⭐⭐ 进阶使用 CompletableFuture 聚合两个异步请求结果

实战题目 1：线程顺序打印 —— A、B、C 顺序打印若干次

📘 真实场景背景：

假设你有三个任务：

  • A：加载用户数据
  • B：加载订单数据
  • C：加载推荐内容

这些任务虽然可以异步执行，但你希望它们始终以 A → B → C 的顺序打印，反复执行若干次用于调试或测试。

🧩 抽象题目描述：启动三个线程，分别负责打印字母 "A"、"B"、"C"，要求按顺序依次输出。

解法：解法：使用 ReentrantLock + Condition

解法

实战题目 2：两个线程交替打印奇偶数

在日志处理、流水号生成、分布式任务切片等系统中，常常需要两个线程协作：

  • 一个处理奇数任务
  • 一个处理偶数任务

比如：

  • 线程 A 负责打印奇数（1,3,5…）
  • 线程 B 负责打印偶数（2,4,6…）

要求两者交替打印，以保证输出顺序正确，避免重复或错位。

🧩 抽象题目描述：

使用两个线程，依次打印数字 1~10，其中一个线程打印奇数，另一个打印偶数，且打印顺序必须正确交替：

Thread-A: 1  
Thread-B: 2  
Thread-A: 3  
Thread-B: 4  
...

解法：使用 synchronized + wait/notify

解法

实战题目 3：线程池并发执行任务并收集所有返回结果

📘 真实场景背景：

你正在开发一个聚合查询系统，用户请求一个接口，你需要：

  • 查询数据库用户信息
  • 调用远程服务查询订单信息
  • 查询推荐系统返回推荐列表

这些任务互不依赖，但都比较耗时。你希望并发执行所有任务并收集结果返回给用户，以缩短响应时间。

🧩 抽象题目描述：

创建一个线程池，并发执行 3 个耗时任务，每个任务都返回结果。主线程等待所有任务完成后，收集它们的返回值并打印出来。

解法：使用 ExecutorService + Callable + Future

解法

实战题目 4：多线程实现生产者-消费者模型

📘 真实场景背景：

你在开发一个图像处理系统，有多个线程不断从设备读取图像（生产者），并将图像放入内存队列中。同时有多个线程从队列中取出图像进行分析（消费者）。

你需要控制好生产与消费之间的节奏，避免：

  • 消费速度过慢，导致内存溢出（队列满）
  • 生产速度过慢，消费者空转（队列空）

🧩 抽象题目描述：

使用多个线程，模拟生产者不断往队列中放入数据，消费者不断从中取出数据，要求使用线程安全的方式实现生产与消费协调，输出每次的操作。

解法：使用 BlockingQueue（推荐实战方式）

解法

实战题目 5：使用 CompletableFuture 聚合多个异步任务结果

📘 真实场景背景：

你在开发一个聚合查询接口，需要同时调用多个微服务：

  • 获取当前用户信息
  • 获取用户订单列表
  • 获取用户推荐商品列表

这些任务彼此没有依赖关系，但都需要并发执行，最终主线程收集所有结果并返回统一响应。

目标是尽可能缩短响应时间，同时支持异常处理。

🧩 抽象题目描述：

使用 CompletableFuture 并发执行 3 个异步任务（模拟耗时 1~2 秒），每个任务返回一段数据，主线程等待所有任务完成后聚合这些数据，并输出结果。

解法：使用 CompletableFuture.supplyAsync() + allOf

解法

版权归属：FelixJY

许可证：署名-禁止演绎 4.0 国际 (CC-BY-ND-4.0)