深入理解Java并发编程：掌握排他性访问的艺术351

在Java并发编程中，确保数据完整性和线程安全是核心挑战之一。当多个线程尝试同时修改共享资源时，如果没有适当的控制，就可能发生竞态条件（Race Condition），导致数据不一致或程序行为不可预测。为了解决这个问题，我们需要引入“排他性访问”（Exclusive Access）的概念，即在任何给定时刻，只允许一个线程访问或修改特定的共享资源或代码段。
本文将深入探讨Java中实现排他性访问的各种方法，从最基础的`synchronized`关键字到``包提供的灵活工具，再到原子操作，帮助您全面理解并掌握在并发环境中保护共享资源的艺术。
---

在多线程应用程序中，共享资源是提高系统吞吐量和响应速度的关键。然而，共享资源也带来了并发编程中最复杂的问题之一：如何确保多个线程在访问或修改同一份数据时不会相互干扰，从而维护数据的一致性和完整性。这个问题的核心在于实现“排他性访问”，即在特定时刻只允许一个线程执行一段关键代码（Critical Section）或访问一个共享变量。Java提供了多种强大的机制来实现排他性访问，本文将为您一一解析。

1. 排他性访问的核心概念与必要性

什么是排他性访问？ 排他性访问是指当一个线程正在对某个共享资源进行读写操作时，其他线程必须等待，直到当前线程完成操作并释放对资源的控制权。这就像图书馆里只有一个座位，当一个人坐着的时候，其他人必须排队等待。

为什么需要排他性访问？ 考虑一个简单的银行账户余额更新场景：两个线程同时尝试向账户存入100元。如果账户初始余额为0元，期望的结果是200元。但如果没有排他性控制，可能会发生以下情况：
线程A读取余额（0元）。
线程B读取余额（0元）。
线程A计算新余额（0 + 100 = 100元）。
线程B计算新余额（0 + 100 = 100元）。
线程A将100元写入余额。
线程B将100元写入余额。

最终余额只有100元，而不是期望的200元。这就是典型的竞态条件和数据不一致问题。排他性访问正是为了避免这类问题而生。

2. `synchronized` 关键字：Java排他性访问的基石

`synchronized` 关键字是Java中最基本的排他性访问控制机制。它可以修饰方法或代码块，提供了一种内置的锁（称为监视器锁或内部锁）。

2.1 `synchronized` 方法

当一个方法被 `synchronized` 修饰时，它会锁定当前实例对象（对于非静态方法）或类的Class对象（对于静态方法）。这意味着在任何时候，只有一个线程可以执行该实例的任何 `synchronized` 非静态方法，或者只有一个线程可以执行该类的任何 `synchronized` 静态方法。
class BankAccount {
private double balance;
public BankAccount(double initialBalance) {
= initialBalance;
}
// 非静态方法，锁定当前BankAccount实例
public synchronized void deposit(double amount) {
(().getName() + " depositing " + amount + "...");
double temp = balance;
try {
(10); // 模拟耗时操作
} catch (InterruptedException e) {
().interrupt();
}
temp += amount;
balance = temp;
(().getName() + " new balance: " + balance);
}
public synchronized double getBalance() {
return balance;
}
}

在上面的例子中，`deposit` 方法被 `synchronized` 修饰，确保了在同一时刻只有一个线程能够修改 `balance` 变量，从而避免了竞态条件。

2.2 `synchronized` 代码块

相比于 `synchronized` 方法，`synchronized` 代码块提供了更细粒度的控制。它允许你指定一个对象作为锁，只锁定需要保护的特定代码段，而不是整个方法。
class BankAccountFineGrained {
private double balance;
private final Object lock = new Object(); // 显式声明一个锁对象
public BankAccountFineGrained(double initialBalance) {
= initialBalance;
}
public void deposit(double amount) {
// 只锁定修改balance的代码段
synchronized (lock) { // 或者 synchronized (this) 也可以
(().getName() + " depositing " + amount + "...");
double temp = balance;
try {
(10); // 模拟耗时操作
} catch (InterruptedException e) {
().interrupt();
}
temp += amount;
balance = temp;
(().getName() + " new balance: " + balance);
}
// 其他不涉及balance的代码可以并行执行
}
public double getBalance() {
// 读取操作如果不需要排他性，可以不加锁，但如果balance的读写必须原子，则也需加锁
// synchronized (lock) { return balance; }
return balance;
}
}

`synchronized` 的优点：

简单易用： 语法简洁，直接内置于Java语言。
可重入性： 一个线程如果已经获得了某个对象的锁，那么它再次尝试获取该对象的锁时会成功，不会导致死锁。
自动释放： 无论是正常退出还是抛出异常，锁都会自动释放，避免了死锁。

`synchronized` 的缺点：

不够灵活： 无法尝试获取锁、无法中断等待锁的线程、也无法知道是否成功获取锁。
粒度粗： 对于某些场景，方法级别的锁可能过粗，限制了并发性。
非公平锁： 默认情况下，`synchronized` 是非公平的，即等待时间最长的线程不一定能优先获得锁。

3. `` 包：更强大的锁机制

Java 5 引入了 `` 包，提供了比 `synchronized` 关键字更灵活、更细粒度的锁机制，主要基于抽象队列同步器（AbstractQueuedSynchronizer, AQS）实现。

3.1 `ReentrantLock`：可重入的互斥锁

`ReentrantLock` 是 `synchronized` 关键字的替代品，提供了相同的基础互斥功能，但具有更高的灵活性和更多的功能。
import ;
class BankAccountWithLock {
private double balance;
private final ReentrantLock lock = new ReentrantLock(); // 显式创建ReentrantLock
public BankAccountWithLock(double initialBalance) {
= initialBalance;
}
public void deposit(double amount) {
(); // 获取锁
try {
(().getName() + " depositing " + amount + "...");
double temp = balance;
try {
(10);
} catch (InterruptedException e) {
().interrupt();
}
temp += amount;
balance = temp;
(().getName() + " new balance: " + balance);
} finally {
(); // 确保在任何情况下都释放锁
}
}
public double getBalance() {
();
try {
return balance;
} finally {
();
}
}
}

`ReentrantLock` 的优点：

显式锁定： 必须手动调用 `lock()` 和 `unlock()` 方法，提供了更高的控制力。
可中断锁： `lockInterruptibly()` 方法允许在等待获取锁时响应中断。
尝试获取锁： `tryLock()` 方法可以尝试获取锁，如果获取失败不会阻塞，可以进行其他操作。
公平性： 可以在构造函数中指定为公平锁（`new ReentrantLock(true)`），这会导致等待时间最长的线程优先获得锁，但会降低吞吐量。
条件变量： 配合 `Condition` 接口，可以实现更复杂的线程间通信机制，替代 `Object` 的 `wait()`, `notify()`, `notifyAll()`。

使用注意事项： 务必在 `finally` 块中调用 `unlock()`，以确保锁在任何情况下都能被释放，避免死锁。

3.2 `ReentrantReadWriteLock`：读写锁分离

在某些场景下，读操作远多于写操作。如果使用 `synchronized` 或 `ReentrantLock`，即使是读操作也会阻塞其他读操作，降低并发性。`ReentrantReadWriteLock` 允许在同一时刻有多个读线程访问共享资源，但只允许一个写线程访问，并且在写线程访问时阻塞所有读线程。
import ;
class DataStore {
private String data = "Initial Data";
private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
private final readLock = ();
private final writeLock = ();
public String readData() {
(); // 获取读锁
try {
(().getName() + " reading data...");
try { (50); } catch (InterruptedException e) { ().interrupt(); }
return data;
} finally {
(); // 释放读锁
}
}
public void writeData(String newData) {
(); // 获取写锁
try {
(().getName() + " writing data...");
try { (100); } catch (InterruptedException e) { ().interrupt(); }
= newData;
} finally {
(); // 释放写锁
}
}
}

优点： 显著提高了读多写少场景下的并发性能。

3.3 `StampedLock`：乐观读锁

`StampedLock` 是Java 8引入的一种更先进的读写锁，它提供了三种模式的锁：写锁、悲观读锁和乐观读锁。乐观读锁在读操作非常频繁且冲突较少时能提供更好的性能，它不阻塞写操作，而是通过一个“戳”（stamp）来验证读取期间是否有写操作发生。

虽然功能强大，但 `StampedLock` 的使用更为复杂，需要仔细处理验证逻辑，并且不支持重入。它适用于极端并发优化的场景。

4. `Semaphore`：控制并发访问数量

`Semaphore`（信号量）是一种更通用的同步工具，它控制同时访问某个特定资源的线程数量。它维护一个许可证计数，线程在访问资源前必须获取许可证，访问完成后释放许可证。
import ;
class ResourcePool {
private final Semaphore semaphore;
private final int capacity;
private final Object[] items;
private final boolean[] used;
public ResourcePool(int capacity) {
= capacity;
= new Semaphore(capacity); // 初始化许可证数量
= new Object[capacity];
= new boolean[capacity];
for (int i = 0; i < capacity; i++) {
items[i] = "Resource-" + i;
}
}
public Object acquireResource() throws InterruptedException {
(); // 获取一个许可证
return getNextAvailableItem();
}
public void releaseResource(Object item) {
if (markAsUnused(item)) {
(); // 释放一个许可证
}
}
private synchronized Object getNextAvailableItem() {
for (int i = 0; i < capacity; i++) {
if (!used[i]) {
used[i] = true;
return items[i];
}
}
return null; // 不应发生，因为semaphore已经保证有空闲资源
}
private synchronized boolean markAsUnused(Object item) {
for (int i = 0; i < capacity; i++) {
if (items[i] == item) {
used[i] = false;
return true;
}
}
return false;
}
}

使用场景： 限制数据库连接池、限制某个服务的并发请求数量等。

5. 原子操作（Atomic Operations）与CAS

对于单个变量的简单操作（如增量、减量、设置值），使用 `synchronized` 或 `ReentrantLock` 可能会带来较大的开销。Java的 `` 包提供了一系列原子类（如 `AtomicInteger`, `AtomicLong`, `AtomicReference`），它们通过无锁（lock-free）的算法实现了线程安全的原子操作。

这些原子类的核心是比较并交换（Compare-And-Swap, CAS）指令。CAS是一种乐观锁机制，它尝试更新一个值，如果这个值在更新期间没有被其他线程修改，则更新成功；否则，更新失败并重试（通常通过循环实现，称为自旋）。
import ;
class Counter {
private AtomicInteger count = new AtomicInteger(0);
public void increment() {
(); // 原子性地将值加1
}
public int getCount() {
return ();
}
}

优点：

无锁： 在低竞争环境下性能通常优于基于锁的机制，因为它避免了线程阻塞和上下文切换。
粒度极细： 针对单个变量的操作。

缺点：

ABA问题： 如果一个值从A变为B，然后又变回A，CAS会认为没有发生变化，这在某些场景下可能导致问题。可以通过带版本号的CAS（如 `AtomicStampedReference`）解决。
仅适用于简单操作： 对于复杂的多变量或多步操作，仍然需要使用锁。

6. 排他性访问的考量与最佳实践

6.1 死锁（Deadlock）

死锁是并发编程中的一个常见问题，当两个或多个线程无限期地互相等待对方释放资源时发生。避免死锁的关键在于破坏死锁发生的四个必要条件之一：互斥、请求与保持、不剥夺、循环等待。

预防策略：

按序获取锁： 规定所有线程获取锁的顺序。
设置超时： `ReentrantLock` 的 `tryLock(long timeout, TimeUnit unit)` 方法可以尝试在一定时间内获取锁，超时未果则放弃。
一次性获取所有锁： 尝试一次性获取所有需要的锁。

6.2 性能与粒度

锁的粒度越细，并发性越高，但管理锁的复杂性也随之增加。反之，锁的粒度越粗，并发性越低，但实现起来可能更简单。
`synchronized` 方法： 粒度最粗。
`synchronized` 代码块： 粒度适中，可根据需求定制。
`ReentrantLock`： 粒度适中，提供更多功能。
`ReentrantReadWriteLock`： 读写分离，适用于读多写少场景。
`Atomic` 类： 粒度最细，无锁，适用于单变量原子操作。

选择合适的排他性机制需要根据具体的应用场景、性能要求和代码复杂性进行权衡。

6.3 可见性（Visibility）

除了排他性，并发编程中还需要关注可见性问题。当一个线程修改了共享变量的值时，其他线程能够立即看到这个新值。`synchronized` 和 `ReentrantLock` 都能保证可见性，因为它们在释放锁时会把工作内存中的数据刷新到主内存，在获取锁时会从主内存中读取最新数据。

`volatile` 关键字也能保证可见性（但不保证原子性），适用于只需要保证可见性而不需要原子性操作的场景。

6.4 异常处理

在使用显式锁（如 `ReentrantLock`）时，务必将 `unlock()` 方法放在 `finally` 块中，以确保即使在加锁代码块中发生异常，锁也能被正确释放，避免资源泄露和死锁。

6.5 Java 21+ 结构化并发

随着Java语言的发展，JDK 21引入了结构化并发（Structured Concurrency）作为预览特性，它旨在通过将相关联的线程生命周期绑定到结构块中，来简化并发程序的推理和错误处理。虽然它不是直接的排他性机制，但它有助于更好地管理线程及其共享资源，从而间接减少并发编程的复杂性和潜在错误。

7. 总结

Java提供了丰富的排他性访问机制，从简单易用的 `synchronized` 关键字到功能强大的 `` 包，再到高性能的原子操作，每种机制都有其独特的适用场景和优缺点。作为专业的程序员，理解这些工具的底层原理、适用范围和性能特点至关重要。

在实际开发中，应根据业务需求、并发模式、性能目标以及团队熟悉度来选择最合适的排他性策略。始终记住，并发编程的核心在于平衡安全性（数据一致性）和性能（吞吐量、响应速度），并在保证正确性的前提下，尽量提高并发度。

2025-10-21

---

上一篇：Java开发减负：从代码优化到高效实践的全方位“解压”指南

下一篇：Java代码追踪深度解析：从基础到高级，掌握调试与性能优化的利器