java线程基础

备案号:蜀ICP备2026035467号-3|网址:www.xservx.com|专注Java并发编程核心知识体系

一、线程基础全景概览

在现代计算环境中,单核CPU性能增长已趋近物理极限,多核架构成为主流。为充分挖掘硬件潜力,**并发编程**成为高性能应用开发的必修课。而**Java线程基础**正是构建可靠、高效并发系统的基石。

线程是操作系统能够进行运算调度的最小单位,被包含在进程之中,是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务。

Java语言从诞生之初就内置了多线程支持。JVM将线程映射到操作系统的原生线程(如Linux的futex机制),通过`java.lang.Thread`类与`java.lang.Runnable`接口提供统一抽象。理解其底层原理与上层实践,是编写高吞吐、低延迟Java应用的前提。

值得注意的是:线程并非越多越好。**线程切换开销**(上下文切换)、**锁竞争**、**内存一致性问题**(如可见性、有序性)等是并发编程中最常见的陷阱。本页面将系统梳理从基础概念到高级实践的完整知识链路,助您避开高频坑点。

以下为**java线程基础**的核心知识图谱:

后续章节将逐层深入,结合**真实业务场景**与**高频面试题**,构建完整知识体系。


1.1 为何必须掌握线程基础?

据2024年Java生态调研显示:92%的中大型应用存在多线程需求;76%的线上故障与并发问题相关;83%的Java高级工程师面试必考并发内容。**java线程基础**不仅是技术能力分水岭,更是系统稳定性、用户体验、成本控制的关键变量。

典型场景包括:

忽视线程基础可能导致:数据不一致(如订单重复扣款)、服务假死(线程池耗尽)、内存泄漏(线程未终止)、性能瓶颈(锁粒度过粗)。


1.2 进程与线程的本质区别

对比维度 进程 线程
定义 程序执行时的实例,拥有独立内存空间 进程内的执行单元,共享进程资源
资源开销 创建/切换开销大(需分配虚拟地址空间) 轻量级,切换开销小(仅保存寄存器/栈)
通信方式 管道、消息队列、共享内存等IPC机制 直接读写共享内存,但需同步机制
隔离性 强隔离(一个崩溃不影响其他进程) 弱隔离(一个线程崩溃可能使进程退出)
Java体现 JVM进程对应一个操作系统进程 每个Thread对象映射一个原生线程

在Java中,通过`Runtime.getRuntime().availableProcessors()`可获取CPU核心数,合理设置线程数(CPU密集型≈核心数,IO密集型≈2×核心数)是性能优化的第一步。

二、线程创建与生命周期管理

Java中创建线程主要有三种方式:继承Thread类、实现Runnable接口、实现Callable接口。每种方式适用场景不同,需结合业务需求选择。

2.1 继承Thread类(不推荐)

由于Java单继承限制,继承Thread会占用宝贵的继承名额。示例:

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("当前线程:" + Thread.currentThread().getName());
    }
}
public class Main {
    public static void main(String[] args) {
        new MyThread().start(); // 启动线程
    }
}

注意:必须调用start()而非run()。直接调用run()只是普通方法调用,不会启动新线程。


2.2 实现Runnable接口(推荐)

解耦任务与线程,支持多实现,更符合面向对象设计原则:

class MyTask implements Runnable {
    @Override
    public void run() {
        // 业务逻辑
    }
}
public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyTask(), "worker-1");
        thread.start();
    }
}

配合Lambda表达式更简洁:

new Thread(() -> System.out.println("Hello Thread"), "task-1").start();

2.3 实现Callable接口(支持返回值)

适用于需要获取线程执行结果的场景,配合Future使用:

class MyCallable implements Callable {
    @Override
    public Integer call() {
        return 123;
    }
}
public class Main {
    public static void main(String[] args) throws Exception {
        FutureTask task = new FutureTask<>(new MyCallable());
        new Thread(task).start();
        System.out.println("结果:" + task.get()); // 阻塞等待结果
    }
}

2.4 线程生命周期详解

Java线程状态由`Thread.State`枚举定义,包含6种状态:

状态 触发条件 典型场景
NEW 线程对象创建后未调用start() new Thread()后未启动
RUNNABLE 调用start()后,等待CPU调度 线程池中活跃线程
BLOCKED 等待进入synchronized块/方法 锁竞争激烈时线程阻塞
WAITING 调用无参wait()、join()、LockSupport.park() 线程间通信等待通知
TIMED_WAITING 调用带参wait(timeout)、sleep()、join(timeout) 定时任务线程休眠
TERMINATED run()方法执行完毕 线程自然结束

2.5 线程中断机制

Java不推荐使用stop()强制终止线程(可能导致资源泄漏),应使用**中断协作机制**:

正确处理中断的示例:

public void run() {
    try {
        while (!Thread.currentThread().isInterrupted()) {
            // 执行任务
            Thread.sleep(1000);
        }
    } catch (InterruptedException e) {
        // 恢复中断状态
        Thread.currentThread().interrupt();
        System.out.println("线程被中断");
    }
}

关键点:捕获InterruptedException后必须恢复中断状态(调用interrupt()),否则会丢失中断信号。


2.6 守护线程(Daemon Thread)

通过`setDaemon(true)`设置。当所有非守护线程结束时,JVM会自动退出,守护线程随之终止。典型应用:GC线程、日志线程。

Thread daemon = new Thread(() -> {
    while (true) {
        System.out.println("守护线程运行中...");
        try { Thread.sleep(1000); } catch (InterruptedException e) {}
    }
});
daemon.setDaemon(true);
daemon.start();

注意:守护线程内创建的子线程默认也是守护线程。

三、线程同步机制深度解析

并发问题的根源在于**共享数据的非原子性操作**。Java提供多种同步机制确保线程安全:synchronized、volatile、显式锁(Lock)、原子变量(Atomic)。

3.1 synchronized关键字

三种使用方式:

方式 锁对象 适用场景
同步实例方法 当前实例对象(this) 保护实例状态
同步静态方法 当前类的Class对象 保护静态资源
同步代码块 指定对象(任意) 精确控制锁粒度

示例:同步代码块避免锁竞争

public void updateCounter() {
    synchronized(this) { // 仅同步关键部分
        counter++;
    }
    // 非关键逻辑不阻塞其他线程
    log.info("Counter updated: " + counter);
}

3.2 volatile关键字

提供可见性保障,确保变量修改对所有线程立即可见。但不保证原子性(如i++仍是非原子操作)。

典型应用场景:

DCL单例正确写法:

public class Singleton {
    private static volatile Singleton instance;
    public static Singleton getInstance() {
        if (instance == null) { // 第一次检查
            synchronized (Singleton.class) {
                if (instance == null) { // 第二次检查
                    instance = new Singleton(); // 非原子操作,volatile防止重排序
                }
            }
        }
        return instance;
    }
}

无volatile时,`new Singleton()`可能被重排序为:1.分配内存→2.设置instance指向内存→3.初始化对象。其他线程可能看到未初始化完成的对象。


3.3 显式锁(Lock)

Lock接口(如ReentrantLock)提供比synchronized更灵活的锁机制:

示例:使用Condition实现生产者-消费者

class BoundedBuffer {
    private final Lock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();
    private final Object[] items = new Object[10];
    private int count, putIndex, takeIndex;
    public void put(Object x) throws InterruptedException {
        lock.lock();
        try {
            while (count == items.length)
                notFull.await();
            items[putIndex] = x;
            if (++putIndex == items.length) putIndex = 0;
            ++count;
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }
    public Object take() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0)
                notEmpty.await();
            Object x = items[takeIndex];
            if (++takeIndex == items.length) takeIndex = 0;
            --count;
            notFull.signal();
            return x;
        } finally {
            lock.unlock();
        }
    }
}

3.4 原子变量(Atomic)

基于CAS(Compare-And-Swap)机制实现无锁并发,适用于简单计数场景:

类 功能 示例
AtomicInteger 整型原子操作 counter.incrementAndGet()
AtomicLong 长整型原子操作 counter.addAndGet(100)
AtomicReference 对象引用原子更新 ref.compareAndSet(old, new)
AtomicStampedReference 解决ABA问题 带版本戳的CAS操作

CAS原理:通过CPU指令(如cmpxchg)实现原子更新,避免线程阻塞。但存在ABA问题(值从A→B→A),需用版本戳解决。

四、线程池原理与参数调优

线程池是并发编程的核心组件,避免频繁创建/销毁线程的开销。Java通过Executor框架提供统一接口。

4.1 线程池核心参数

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)
参数 说明 推荐值
corePoolSize 核心线程数 CPU密集型≈核心数;IO密集型≈2×核心数
maximumPoolSize 最大线程数 核心数×(1+IO等待时间/计算时间)
keepAliveTime 非核心线程存活时间 30秒(通用)
workQueue 任务队列 SynchronousQueue(快速响应)/LinkedBlockingQueue(高吞吐)
handler 拒绝策略 CallerRunsPolicy(回压)/AbortPolicy(快速失败)

4.2 线程池工作流程

当新任务提交时:

  1. 当前线程数 < corePoolSize → 创建新线程处理
  2. 当前线程数 ≥ corePoolSize → 任务进入队列
  3. 队列满且线程数 < maximumPoolSize → 创建新线程
  4. 线程数已达最大 → 执行拒绝策略

示例:自定义线程池(防止OOM)

ExecutorService executor = new ThreadPoolExecutor(
    4, // corePoolSize
    8, // maximumPoolSize
    30L, TimeUnit.SECONDS,
    new SynchronousQueue<>(), // 无缓冲队列
    new ThreadFactoryBuilder().setNameFormat("worker-%d").build(),
    new ThreadPoolExecutor.CallerRunsPolicy() // 回压策略
);

避免使用Executors静态工厂(如newFixedThreadPool),因其使用无界队列可能导致OOM。


4.3 常见线程池类型对比

类型 核心参数 适用场景 风险
FixedThreadPool core=max, 无界队列 任务量稳定、耗时短 任务堆积导致OOM
CachedThreadPool core=0, max=Integer.MAX 大量短生命周期任务 线程数爆炸
SingleThreadExecutor core=max=1, 无界队列 顺序执行任务 任务堆积导致OOM
ScheduledThreadPool 支持定时/周期任务 定时任务、心跳检测 任务延迟累积

生产环境建议:自定义ThreadPoolExecutor,明确参数边界。

五、并发工具类实战指南

JUC(java.util.concurrent)提供了丰富的并发工具,简化复杂同步逻辑。

5.1 CountDownLatch(倒计时门栓)

允许一个或多个线程等待其他线程完成操作。典型场景:主线程等待多个子线程初始化完成。

CountDownLatch latch = new CountDownLatch(3);
// 子线程1
new Thread(() -> {
    // 初始化操作
    latch.countDown();
}).start();
// 主线程等待
latch.await();
System.out.println("所有初始化完成!");

5.2 CyclicBarrier(循环栅栏)

一组线程等待到达屏障点后继续执行,可重用。典型场景:多线程计算数据后合并结果。

CyclicBarrier barrier = new CyclicBarrier(3, () -> {
    System.out.println("所有线程到达屏障,执行汇总!");
});
// 三个线程
for (int i = 0; i < 3; i++) {
    new Thread(() -> {
        // 计算操作
        barrier.await(); // 等待其他线程
        // 汇总结果
    }).start();
}

5.3 Semaphore(信号量)

控制同时访问特定资源的线程数。典型场景:数据库连接池、限流。

Semaphore semaphore = new Semaphore(5); // 5个许可证
// 获取许可证
semaphore.acquire();
try {
    // 访问资源
} finally {
    semaphore.release(); // 必须释放
}

5.4 Future与CompletableFuture

CompletableFuture提供异步编程API,支持函数式组合:

CompletableFuture future = CompletableFuture
    .supplyAsync(() -> "Hello")
    .thenApply(s -> s + " World")
    .thenCompose(s -> CompletableFuture
        .supplyAsync(() -> s + "!"))
    .exceptionally(ex -> "Error: " + ex.getMessage());
System.out.println(future.get()); // Hello World!

优势:避免回调地狱,支持链式调用,自动处理异常。

六、线程安全与JMM深度解析

6.1 线程安全的三大问题

问题 原因 解决方案
原子性 多线程执行非原子操作 synchronized、Atomic、Lock
可见性 线程工作内存与主内存不同步 volatile、synchronized、Lock
有序性 指令重排序导致逻辑错误 volatile、happens-before规则

6.2 Java内存模型(JMM)核心规则

JMM定义了线程与主内存的交互协议,通过happens-before原则保证内存可见性:

  1. 程序次序规则:线程内代码按序happens-before
  2. 监视器锁规则:解锁synchronized前happens-before后续加锁
  3. volatile变量规则:写volatile前happens-before后续读
  4. 线程启动规则:start()前happens-before新线程执行
  5. 线程终止规则:线程内所有操作happens-before join()返回
  6. 中断规则:interrupt()前happens-before检测到中断
  7. 终结器规则:对象构造前happens-beforefinalize()

示例:volatile确保可见性

class VolatileExample {
    volatile boolean initialized = false;
    Data data;
    void init() {
        data = new Data(); // 1. 分配内存
        initialized = true; // 2. 设置标志(happens-before后续读)
    }
    void use() {
        if (initialized) {
            // 保证看到完整初始化的data
            process(data);
        }
    }
}

6.3 常见线程安全容器

容器 线程安全特性 适用场景
ConcurrentHashMap 分段锁(JDK8+ CAS+synchronized) 高并发读写Map
CopyOnWriteArrayList 写时复制(加锁+数组复制) 读多写少(如监听器列表)
ConcurrentLinkedQueue 无锁CAS实现 高吞吐队列
BlockingQueue 生产者-消费者模型 任务队列、消息缓冲

七、并发性能优化策略

7.1 锁优化技巧


7.2 避免死锁的实践

死锁四条件:互斥、占有且等待、不可抢占、循环等待。预防策略:

  1. 固定加锁顺序(如按对象哈希码排序)
  2. 使用tryLock(timeout)避免无限等待
  3. 减少锁持有时间(只同步关键代码)
  4. 使用同步工具类(如CountDownLatch)替代手动锁

死锁诊断命令:

jstack -l [pid] | grep -A 10 "Found.*deadlock"

7.3 上下文切换优化

频繁切换导致CPU缓存失效。优化方法:

监控命令:

vmstat 1 | awk '{print $15}' # cs列:上下文切换次数/秒

八、真实业务案例解析

8.1 订单超时取消

问题:用户下单后30分钟未支付则自动取消订单。

错误做法:为每个订单创建Timer(线程泄漏风险)。

正确方案:使用DelayQueue(优先级队列)+ 单线程消费者

class OrderTask implements Delayed {
    private final String orderId;
    private final long expireTime;
    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(expireTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
    }
    @Override
    public int compareTo(Delayed o) {
        return Long.compare(this.expireTime, ((OrderTask)o).expireTime);
    }
}
// 消费者
new Thread(() -> {
    while (!Thread.interrupted()) {
        try {
            OrderTask task = delayQueue.take();
            cancelOrder(task.getOrderId());
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}).start();

8.2 批量数据导出

问题:10万条数据导出,单线程耗时过长。

优化方案:分页查询 + 线程池并行处理

int total = 100000;
int batchSize = 1000;
int pages = (total + batchSize - 1) / batchSize;
ExecutorService pool = new ThreadPoolExecutor(
    8, 16, 30L, TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(100),
    new ThreadFactoryBuilder().setNameFormat("export-%d").build(),
    new ThreadPoolExecutor.CallerRunsPolicy()
);
CountDownLatch latch = new CountDownLatch(pages);
for (int i = 0; i < pages; i++) {
    int page = i;
    pool.submit(() -> {
        try {
            List batch = queryBatch(page * batchSize, batchSize);
            exportBatch(batch);
        } finally {
            latch.countDown();
        }
    });
}
latch.await(); // 等待全部完成
pool.shutdown();

注意:导出文件需线程安全(如使用ThreadLocal的BufferedWriter)。

九、高频面试题精解

9.1 synchronized与ReentrantLock区别


9.2 volatile能否保证原子性?

不能。volatile仅保证可见性和有序性,不保证原子性。如i++包含读-改-写三步,需用AtomicInteger。


9.3 线程池拒绝策略选择

策略 行为 适用场景
AbortPolicy 抛异常 测试环境(快速失败)
CallerRunsPolicy 调用者线程执行 生产环境(限流回压)
DiscardPolicy 静默丢弃 可容忍丢弃的场景
DiscardOldestPolicy 丢弃队列头任务 实时性要求高的任务

十、网友最关心问题答疑

线程池大小设置公式

根据任务类型调整:

  • CPU密集型:corePoolSize ≈ CPU核心数 + 1
  • IO密集型:corePoolSize ≈ CPU核心数 × (1 + IO耗时/计算耗时)
  • 混合型:按主要类型调整,或拆分线程池

实测建议:通过压测工具(JMeter)逐步增加线程数,观察TPS拐点。

volatile与synchronized性能

JDK6后synchronized引入偏向锁/轻量级锁,性能大幅提升:

场景 synchronized volatile
无竞争 极快(偏向锁) 快(仅内存屏障)
低竞争 快(自旋锁) 快
高竞争 中等(阻塞) 慢(CAS失败重试)

结论:优先用synchronized;高竞争计数场景用Atomic。

死锁诊断步骤

  1. 用jps定位Java进程ID
  2. 执行jstack -l [pid] > dump.txt
  3. 搜索"Found 1 deadlock"
  4. 分析堆栈:找到持锁线程与等待线程
  5. 用jconsole可视化监控线程状态

预防:统一加锁顺序 + 减少锁嵌套 + 使用tryLock超时。

ThreadLocal内存泄漏

ThreadLocalMap使用弱引用持有key,但value是强引用:

  • 线程结束 → ThreadLocalMap清除 → 无泄漏
  • 线程复用(线程池)→ key被GC → value无法访问 → 泄漏

解决方案:使用后调用remove();线程池中避免复用ThreadLocal。