Java 中的并发（Concurrency） 指多个任务在同一时间段内交替执行（宏观上同时进行，微观上可能是 CPU 快速切换调度），目的是提高程序效率，充分利用系统资源（如 CPU、内存、I/O 等）。
一、为什么需要并发？
资源利用率最大化
当程序执行 I/O 操作（如读写文件、网络请求）时，CPU 通常处于空闲状态。通过并发，可在等待 I/O 时让 CPU 处理其他任务，避免资源浪费。
例如：一个下载文件的程序，在等待网络数据时，可同时解析已下载的部分数据。响应速度提升
对于交互式程序（如 GUI 应用、服务器），并发能避免单任务阻塞导致的界面卡顿或请求超时。
例如：Web 服务器同时处理多个用户的请求，而非逐个排队处理。
二、并发的核心概念
1. 线程（Thread）与进程（Process）
- 进程：程序的一次执行过程，是系统资源分配的基本单位（有独立的内存空间）。
- 线程：进程内的执行单元，是 CPU 调度的基本单位（共享进程的内存空间）。
- 关系：一个进程可包含多个线程（多线程），线程间切换成本远低于进程切换。
2. 并行（Parallelism）与并发（Concurrency）的区别
- 并发：多个任务“交替执行”（CPU 切换速度快，看起来同时进行），适用于单 CPU 或多 CPU。
- 并行：多个任务“同时执行”（需多 CPU 核心，每个核心处理一个任务）。
例如：4 核 CPU 同时运行 4 个线程是并行，1 核 CPU 快速切换 4 个线程是并发。
三、Java 实现并发的方式
Java 提供了多种并发编程工具，核心是通过线程实现：
1. 基础方式
- 继承
Thread类：重写run()方法定义任务，调用start()启动线程。 - 实现
Runnable接口：定义任务逻辑，通过Thread类包装并启动（推荐，避免单继承限制）。 实现
Callable接口：与Runnable类似，但可返回结果并抛出异常，配合Future获取结果。// Callable 示例 import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; public class CallableDemo { public static void main(String[] args) throws ExecutionException, InterruptedException { // 1. 定义任务（有返回值） Callable<Integer> task = () -> { int sum = 0; for (int i = 0; i <= 100; i++) { sum += i; } return sum; }; // 2. 包装任务 FutureTask<Integer> futureTask = new FutureTask<>(task); // 3. 启动线程 new Thread(futureTask).start(); // 4. 获取结果（会阻塞直到任务完成） System.out.println("1-100的和：" + futureTask.get()); // 输出5050 } }
2. 线程池（ThreadPoolExecutor）
频繁创建/销毁线程会消耗资源，线程池通过复用线程提高效率，是生产环境的首选。
Java 提供 Executors 工具类快速创建线程池：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolDemo {
public static void main(String[] args) {
// 创建固定大小的线程池（3个线程）
ExecutorService pool = Executors.newFixedThreadPool(3);
// 提交5个任务（线程池会复用3个线程处理）
for (int i = 0; i < 5; i++) {
int taskId = i;
pool.submit(() -> {
System.out.println("处理任务" + taskId + "，线程：" + Thread.currentThread().getName());
});
}
// 关闭线程池
pool.shutdown();
}
}
四、并发带来的问题及解决方案
并发虽提高效率，但多线程共享资源时会引发问题：
1. 线程安全问题
当多个线程同时操作共享数据（如全局变量、集合），可能导致数据不一致。
示例：两个线程同时对变量 count 做 ++ 操作，预期结果为 2，实际可能为 1（因 ++ 是多步操作，可能被打断）。
2. 解决方案
synchronized关键字：通过“锁”保证同一时间只有一个线程执行临界区代码（修饰方法或代码块）。public class SynchronizedDemo { private static int count = 0; private static final Object lock = new Object(); // 锁对象 public static void main(String[] args) throws InterruptedException { Thread t1 = new Thread(() -> { for (int i = 0; i < 10000; i++) { synchronized (lock) { // 同步代码块：同一时间只有一个线程进入 count++; } } }); Thread t2 = new Thread(() -> { for (int i = 0; i < 10000; i++) { synchronized (lock) { count++; } } }); t1.start(); t2.start(); t1.join(); // 等待线程执行完毕 t2.join(); System.out.println("count最终值：" + count); // 正确输出20000 } }java.util.concurrent工具类：提供线程安全的集合（如ConcurrentHashMap）、原子类（如AtomicInteger）、锁机制（如ReentrantLock）等，比synchronized更灵活。
五、并发编程的核心挑战
可见性：一个线程修改的共享变量，其他线程可能无法立即看到（因 CPU 缓存导致）。
解决方案：使用volatile关键字（保证变量修改后立即刷新到主内存）。原子性：一个操作不可被中断（如
count++实际是“读-改-写”三步，非原子操作）。
解决方案：synchronized、原子类（AtomicInteger）。有序性：CPU 可能对指令重排序优化，导致代码执行顺序与预期不一致。
解决方案：volatile、synchronized或显式内存屏障。
六、总结
- 并发的本质：通过多线程交替执行，提高资源利用率和程序响应速度。
- 核心问题：线程安全（数据不一致），需通过锁机制或并发工具解决。
- 实践建议：优先使用线程池管理线程，避免手动创建；复杂场景下借助
java.util.concurrent包的工具类（如CountDownLatch、Semaphore）简化开发。
理解并发是 Java 进阶的关键，尤其在高并发场景（如分布式系统、高流量服务器）中，合理设计并发模型能显著提升系统性能。
