Java 中的并发编程：深入理解线程、Executor 和同步机制

2501_94188140

621人浏览 · 2025-11-17 17:23:02

2501_94188140 · 2025-11-17 17:23:02 发布

在现代的 Java 开发中，性能和并发性是至关重要的因素，尤其是在高负载、高并发的应用程序中。为了更好地利用多核处理器，Java 提供了丰富的并发编程机制，从基础的线程控制到高级的并发工具库，使得开发者能够编写高效且线程安全的程序。

本文将深入探讨 Java 中的并发编程，从线程的基本概念、线程池的使用，到同步机制的实现，帮助开发者掌握并发编程的核心技术，并在实际项目中高效地应用。

1. 线程基础

线程是程序执行的基本单位。在 Java 中，每个 Java 应用程序至少有一个线程，也就是主线程（main thread）。线程的执行是并行的，可以使程序同时进行多个任务，从而提升程序的性能。

1.1 创建和启动线程

在 Java 中，有两种常用的方式来创建线程：继承 Thread 类和实现 Runnable 接口。

使用 Thread 类：

class MyThread extends Thread { @Override public void run() { System.out.println("Thread is running"); } } public class ThreadExample { public static void main(String[] args) { MyThread thread = new MyThread(); thread.start(); // 启动线程 } }

使用 Runnable 接口：

class MyRunnable implements Runnable { @Override public void run() { System.out.println("Runnable thread is running"); } } public class RunnableExample { public static void main(String[] args) { Thread thread = new Thread(new MyRunnable()); thread.start(); // 启动线程 } }

使用 Runnable 接口更加灵活，因为它允许将线程逻辑与线程的实现分离，可以方便地复用。

1.2 线程的生命周期

线程在其生命周期中可以经历以下几种状态：

新建状态（New）：线程被创建，但尚未启动。
就绪状态（Runnable）：线程已准备好并等待 CPU 调度执行。
运行状态（Running）：线程正在执行中。
阻塞状态（Blocked）：线程等待获取资源（如锁）。
终止状态（Terminated）：线程执行完成。

2. 线程池（Executor Framework）

创建和管理线程的直接方式可能导致资源的浪费，特别是在需要频繁创建和销毁线程时。Java 提供了 Executor 框架来解决这个问题，允许开发者重用线程池中的线程，从而提高程序的性能。

2.1 创建线程池

ExecutorService 是 Java 中用于管理线程池的接口，Executors 类提供了一些工厂方法来创建常用的线程池。

示例：使用 FixedThreadPool 创建一个固定大小的线程池

import java.util.concurrent.*; public class ThreadPoolExample { public static void main(String[] args) { ExecutorService executor = Executors.newFixedThreadPool(2); // 创建固定大小为2的线程池 for (int i = 0; i < 5; i++) { executor.submit(new Task(i)); // 提交任务 } executor.shutdown(); // 关闭线程池 } static class Task implements Runnable { private int taskId; public Task(int taskId) { this.taskId = taskId; } @Override public void run() { System.out.println("Executing task " + taskId); } } }

在这个例子中，线程池会为提交的任务提供线程，最多有 2 个线程同时执行任务，其他任务会在有线程空闲时执行。

2.2 线程池的好处

使用线程池有多个优势：

减少了线程创建和销毁的开销：线程池中的线程可以重用，从而避免了频繁创建和销毁线程的性能消耗。
提高了资源的利用率：线程池能够根据系统负载动态调整线程的数量，避免了线程过多或过少的情况。
简化了线程管理：通过线程池，开发者无需手动管理线程的生命周期，线程池会自动进行管理。

3. 同步机制

在多线程编程中，多个线程可能会访问共享资源，这就导致了线程安全问题。为了保证多个线程对共享资源的访问不发生冲突，Java 提供了多种同步机制。

3.1 使用 `synchronized` 关键字

synchronized 是 Java 中最常用的同步工具。它可以确保某个代码块在同一时刻只能由一个线程访问，防止数据竞争和不一致问题。

示例：使用 synchronized 实现线程安全

class Counter { private int count = 0; public synchronized void increment() { count++; } public synchronized int getCount() { return count; } } public class SynchronizedExample { public static void main(String[] args) { Counter counter = new Counter(); Runnable task = () -> { for (int i = 0; i < 1000; i++) { counter.increment(); } }; Thread thread1 = new Thread(task); Thread thread2 = new Thread(task); thread1.start(); thread2.start(); try { thread1.join(); thread2.join(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Final count: " + counter.getCount()); } }

在这个例子中，increment() 方法是同步的，确保了多个线程在访问 count 时不会发生冲突。

3.2 使用 `ReentrantLock`

除了 synchronized，Java 还提供了更强大的锁机制，如 ReentrantLock。与 synchronized 不同，ReentrantLock 提供了更多的灵活性，例如尝试获取锁、定时锁等功能。

示例：使用 ReentrantLock 实现线程安全

import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; class Counter { private int count = 0; private final Lock lock = new ReentrantLock(); public void increment() { lock.lock(); // 获取锁 try { count++; } finally { lock.unlock(); // 确保释放锁 } } public int getCount() { return count; } } public class LockExample { public static void main(String[] args) { Counter counter = new Counter(); Runnable task = () -> { for (int i = 0; i < 1000; i++) { counter.increment(); } }; Thread thread1 = new Thread(task); Thread thread2 = new Thread(task); thread1.start(); thread2.start(); try { thread1.join(); thread2.join(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Final count: " + counter.getCount()); } }

使用 ReentrantLock，我们显式地控制锁的获取和释放，从而提供了比 synchronized 更精细的锁控制。