深入浅出 Java 多线程：从基础到实战-CSDN博客

本文链接：https://blog.csdn.net/2202_75601845/article/details/147429089

引言

在 Java 开发领域，多线程技术堪称提升程序性能的关键 “利器”。无论是高并发的网络服务，还是资源密集型的计算任务，合理运用多线程都能显著优化程序执行效率。本文将由浅入深，系统讲解 Java 线程的核心概念、使用场景及最佳实践，助你夯实高并发编程的基石，为进阶高级 Java 开发铺平道路。

一、线程基础概念

1.1 进程与线程

进程是操作系统分配资源的基本单位，每个进程都拥有独立的内存空间、文件描述符等系统资源，不同进程间相互隔离，保障了程序运行的安全性和稳定性。例如，当我们同时打开浏览器、音乐播放器和文本编辑器时，操作系统会为它们各自创建独立的进程，每个进程互不干扰地运行。

线程则是进程内的最小执行单元，作为 “轻量级进程”，线程共享所属进程的资源，如内存空间、打开的文件等，这使得线程间通信和切换的成本远低于进程。在一个音乐播放器进程中，可能存在多个线程：一个线程负责音频解码，一个线程处理用户界面交互，还有一个线程进行网络请求获取歌曲信息。通过多线程协作，音乐播放器能够同时高效地完成多项任务。

1.2 Java 线程实现方式

方式 1：继承 Thread 类

继承 Thread 类是创建 Java 线程的基础方式之一。通过继承 Thread 类，并重写其 run 方法，将需要在新线程中执行的代码逻辑编写在 run 方法内。然而，这种方式存在一定局限性。由于 Java 不支持多重继承，当一个类继承了 Thread 类后，便无法再继承其他类，限制了类的扩展性。因此，在实际开发中，该方式的使用频率相对较低。

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread running: " + Thread.currentThread().getName());
    }
}

// 启动线程
new MyThread().start();

方式 2：实现 Runnable 接口（推荐）

实现 Runnable 接口是更为推荐的线程创建方式。这种方式将线程任务与线程对象分离，一个类实现 Runnable 接口，只需专注于定义线程要执行的任务逻辑，而线程对象的创建和管理则由Thread 类负责。这种方式的优势在于，实现 Runnable 接口的类还可以继承其他类，满足了代码复用和扩展的需求。同时，多个线程可以共享同一个 Runnable 实例，便于资源共享和协作。

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable thread: " + Thread.currentThread().getName());
    }
}

// 启动线程
new Thread(new MyRunnable()).start();

方式 3：Lambda 表达式（Java8+）

Java 8 引入的 Lambda 表达式为创建线程提供了更为简洁的语法。Lambda 表达式可以将一段代码块作为参数传递，适用于只需要执行简单任务的线程创建场景。Lambda 表达式使代码更加简洁、易读，尤其在创建一次性、短生命周期的线程时，极大地简化了代码编写。

new Thread(() -> {
    System.out.println("Lambda thread: " + Thread.currentThread().getName());
}).start();

二、线程生命周期

线程从创建到结束，会经历一系列不同的状态，这些状态构成了线程的生命周期。借助线程生命周期图，可以更直观地理解线程状态的转换过程。

状态转换

NEW → RUNNABLE (start())：当通过new Thread()创建一个线程对象时，线程处于 NEW（新建）状态，此时线程尚未开始执行。调用start()方法后，线程进入 RUNNABLE（可运行）状态，等待 CPU 调度执行。

RUNNABLE ↔ BLOCKED (同步锁)：当线程尝试获取一个被其他线程占用的同步锁（如synchronized关键字修饰的代码块）时，如果锁不可用，线程会从 RUNNABLE 状态转换为 BLOCKED（阻塞）状态，进入等待队列。直到获取到锁，线程才会重新回到 RUNNABLE 状态。

RUNNABLE ↔ WAITING (wait()/join())：调用wait()方法或join()方法时，线程会从 RUNNABLE 状态进入 WAITING（等待）状态。wait()方法通常用于线程间的协作，使当前线程等待其他线程的通知；join()方法用于等待另一个线程执行完毕。线程处于 WAITING 状态时，会释放持有的锁资源，直到被其他线程唤醒或目标线程执行结束。

RUNNABLE ↔ TIMED_WAITING (sleep()/wait(timeout))：与 WAITING 状态类似，TIMED_WAITING（限时等待）状态也是线程暂停执行的一种状态。通过调用Thread.sleep(long millis)方法或wait(long timeout)方法，线程会进入 TIMED_WAITING 状态，在指定的时间内暂停执行。到达指定时间后，线程会自动恢复到 RUNNABLE 状态。

→ TERMINATED (执行结束)：当线程的 run 方法执行完毕，或者因异常终止时，线程进入 TERMINATED（终止）状态，此时线程的生命周期结束，不再被 CPU 调度执行。

三、线程同步机制

在多线程环境下，多个线程可能同时访问共享资源，若不进行适当的同步控制，就会导致数据不一致、竞态条件等问题。Java 提供了多种线程同步机制，以确保线程安全。

3.1 synchronized 关键字

synchronized关键字是 Java 中最基本的同步方式，它可以修饰方法或代码块。当一个线程进入synchronized修饰的方法或代码块时，会自动获取对象锁，其他线程在该锁被释放前无法进入，从而保证同一时刻只有一个线程能访问共享资源。

class Counter {
    private int count = 0;
    
    public synchronized void increment() {
        count++;
    }
}

上述代码中，increment方法被synchronized修饰，保证了在多线程环境下，count变量的自增操作是线程安全的。synchronized关键字使用简单，但在高并发场景下，可能会因为锁竞争导致性能下降。

3.2 ReentrantLock（更灵活）

ReentrantLock是 JUC（java.util.concurrent）包提供的可重入锁，相比synchronized关键字，它提供了更灵活的锁控制和更高的性能。ReentrantLock支持公平锁和非公平锁模式，还能通tryLock()方法尝试获取锁，避免线程长时间阻塞。

class Counter {
    private final Lock lock = new ReentrantLock();
    private int count = 0;
    
    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

在使用ReentrantLock时，需要手动调用lock()方法获取锁，在操作完成后，必须在finally块中调用unlock()方法释放锁，以确保即使发生异常，锁也能被正确释放。

3.3 volatile 关键字

volatile关键字主要用于保证多线程环境下变量的可见性。当一个变量被声明为volatile时，线程对该变量的修改会立即同步到主内存，其他线程读取该变量时也会从主内存获取最新值，避免了线程缓存导致的数据不一致问题。

private volatile boolean flag = false;
// 保证多线程间的可见性

需要注意的是，volatile关键字并不能保证原子性，对于复合操作（如自增、自减），仍需结合其他同步机制来保证线程安全。

四、线程池实战（重点！）

线程池是多线程编程中的重要工具，它通过复用已创建的线程，避免了频繁创建和销毁线程带来的性能开销，提高了程序的执行效率和资源利用率。

4.1 创建线程池

Java 提供了Executors工具类，方便开发者快速创建不同类型的线程池。例如，使用Executors.newFixedThreadPool(int nThreads)方法可以创建一个固定大小的线程池，池中始终保持指定数量的线程。

ExecutorService executor = Executors.newFixedThreadPool(5);

上述代码创建了一个包含 5 个线程的线程池，当有任务提交时，线程池会分配空闲线程执行任务。如果所有线程都在忙碌，新任务会被放入队列等待执行。

4.2 ThreadPoolExecutor 参数详解

ThreadPoolExecutor是线程池的核心实现类，通过配置不同的参数，可以灵活地控制线程池的行为。

new ThreadPoolExecutor(
    corePoolSize, // 核心线程数
    maximumPoolSize, // 最大线程数
    keepAliveTime, // 空闲线程存活时间
    TimeUnit.MILLISECONDS, // 时间单位
    new LinkedBlockingQueue<>(), // 工作队列
    Executors.defaultThreadFactory(), // 线程工厂
    new ThreadPoolExecutor.AbortPolicy() // 拒绝策略
);

corePoolSize：核心线程数，线程池创建后，会先创建核心线程数数量的线程，即使这些线程处于空闲状态，也不会被销毁。

maximumPoolSize：最大线程数，线程池允许创建的最大线程数量。当工作队列已满且任务数超过核心线程数时，线程池会创建新的线程，直到达到最大线程数。

keepAliveTime：空闲线程存活时间，当线程池中的线程数量超过核心线程数时，空闲线程在等待指定时间后，若没有新任务分配，会被销毁。

TimeUnit：时间单位，用于指定keepAliveTime的时间单位，如毫秒、秒、分钟等。

工作队列：用于存储等待执行的任务。常见的工作队列有ArrayBlockingQueue（有界队列）、LinkedBlockingQueue（无界队列）等。

线程工厂：用于创建线程的工厂，通过自定义线程工厂，可以设置线程的名称、优先级、是否为守护线程等属性。

拒绝策略：当线程池无法接受新任务时（如工作队列已满且线程数达到最大线程数），会执行拒绝策略。常见的拒绝策略有AbortPolicy（抛出异常）、CallerRunsPolicy（由调用线程执行任务）、DiscardPolicy（丢弃任务）、DiscardOldestPolicy（丢弃队列中最老的任务，然后尝试执行新任务）。

4.3 任务提交方式

线程池提供了两种任务提交方式，分别用于执行无返回值任务和有返回值任务。

executor.execute(() -> {...});

Future<Integer> future = executor.submit(() -> {
    // 计算任务
    return 42;
});

execute()方法用于提交无返回值的任务，适用于简单的任务执行场景。submit()方法用于提交有返回值的任务，它返回一个Future对象，通过Future对象可以获取任务的执行结果，还能判断任务是否完成、取消任务等。

五、常见问题与解决方案

在多线程编程中，会面临各种问题，如死锁、线程安全问题等。了解这些问题的成因和解决方案，是编写稳定、高效多线程程序的关键。

5.1 死锁预防

死锁是指多个线程在执行过程中，因争夺资源而造成的一种互相等待的僵局，若无外力干涉，这些线程都将无法继续执行。为预防死锁，可以采取以下措施：

避免嵌套锁：尽量避免在一个线程中同时获取多个锁，若必须获取多个锁，应确保获取锁的顺序一致，避免形成锁循环。

使用定时锁（tryLock）：ReentrantLock的tryLock()方法可以尝试获取锁，并在指定时间内返回获取结果。如果在规定时间内未能获取锁，线程可以采取其他处理方式，避免无限等待。

按固定顺序获取锁：为多个锁设定一个固定的获取顺序，所有线程都按照该顺序获取锁，这样可以避免因获取锁的顺序不同而导致的死锁。

5.2 线程安全集合

在多线程环境下，使用普通的集合类（如ArrayList、HashMap）可能会导致线程安全问题。Java 提供了多种线程安全的集合类，用于满足多线程环境下的数据存储和操作需求。

Collections.synchronizedList()方法返回一个线程安全的 List 集合，通过对方法进行同步控制，保证了多线程访问的安全性。ConcurrentHashMap是一个高效的线程安全 Map 集合，它采用分段锁机制，允许多个线程同时访问不同的段，提高了并发性能。

5.3 ThreadLocal 使用

ThreadLocal提供了线程局部变量，每个线程都拥有自己独立的变量副本，不同线程之间的变量互不干扰。这在处理线程安全问题时非常有用，例如每个线程需要维护自己的会话信息、数据库连接等。

private static ThreadLocal<SimpleDateFormat> dateFormat = 
    ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd"));

上述代码创建了一个ThreadLocal实例，用于存储SimpleDateFormat对象。每个线程在访问dateFormat时，都会获取到属于自己的SimpleDateFormat实例，避免了多线程共享SimpleDateFormat对象导致的线程安全问题。

六、性能优化建议

为了充分发挥多线程的性能优势，在编写多线程程序时，可以参考以下性能优化建议：

优先使用线程池而非直接创建线程：线程池通过复用线程，减少了线程创建和销毁的开销，提高了资源利用率。同时，线程池还提供了统一的线程管理和监控机制，便于程序的维护和优化。

减少锁粒度（使用细粒度锁）：尽量缩小锁的作用范围，只对必要的共享资源进行加锁，避免锁竞争。例如，使用ConcurrentHashMap的分段锁机制，相比对整个 Map 加锁，能显著提高并发性能。

使用 ReadWriteLock 处理读写分离场景：在读取操作远多于写入操作的场景下，使用ReadWriteLock可以提高并发性能。ReadWriteLock允许多个线程同时进行读操作，但在写操作时会独占锁，保证了数据的一致性。

考虑使用 CompletableFuture 进行异步编排（Java8+）：CompletableFuture提供了丰富的异步编程接口，可以方便地实现任务的组合、异步回调、异常处理等功能。通过CompletableFuture，可以更灵活地编排多个异步任务，提高程序的执行效率和响应性。

结语

掌握 Java 多线程技术是进阶高级 Java 开发的必经之路。多线程编程不仅能提升程序性能，还能拓展程序的功能边界，但同时也伴随着线程安全、死锁等复杂问题。建议读者通过实际项目练习，将理论知识应用于实践，加深对多线程概念和技术的理解。此外，结合 JUC（java.util.concurrent）工具包进行深入学习和实践，能够进一步提升多线程编程能力，编写出高效、稳定的多线程程序。

上述内容从多方面丰富了文章，使 Java 多线程知识讲解更全面深入。若你觉得某些部分还需调整，或想补充其他内容，欢迎随时告诉我。