Java编程实战高效实现多线程并发控制的五种方法

原创于 2025-11-14 15:50:09 发布 · 863 阅读

6 ·

CC 4.0 BY-SA版权

文章标签：

#远程工作

### 一、synchronized关键字

synchronized是Java中最基础的线程同步机制，通过对象监视器实现互斥访问。每个Java对象都内置一个监视器锁，当线程进入synchronized修饰的代码块时自动获取锁，退出时释放锁。

实战场景：银行账户取款操作

```java

public class BankAccount {

private double balance;

public synchronized void withdraw(double amount) {

if(balance >= amount) {

balance -= amount;

}

// 同步代码块方式

public void deposit(double amount) {

synchronized(this) {

balance += amount;

}

```

技术要点：

- 实例方法同步使用对象锁

- 静态方法同步使用类对象锁

- 支持可重入特性

- 使用wait()/notify()实现线程间协作

### 二、ReentrantLock显式锁

java.util.concurrent.locks.ReentrantLock提供了比synchronized更灵活的锁机制，支持公平锁、可中断锁等待等高级特性。

实战场景：高并发订单处理

```java

public class OrderService {

private final ReentrantLock lock = new ReentrantLock(true); // 公平锁

private Map orderMap = new HashMap<>();

public void processOrder(String orderId) {

lock.lock();

try {

Order order = orderMap.get(orderId);

// 订单处理逻辑

updateInventory(order);

calculateRevenue(order);

} finally {

lock.unlock();

}

// 尝试获取锁

public boolean tryProcessOrder(String orderId) {

if(lock.tryLock(1, TimeUnit.SECONDS)) {

try {

return processImmediately(orderId);

} finally {

lock.unlock();

}

return false;

}

```

技术优势：

- 支持公平性选择

- 可中断的锁获取

- 超时锁获取尝试

- 条件变量支持

### 三、ReadWriteLock读写锁

java.util.concurrent.locks.ReadWriteLock通过读写分离提升并发性能，允许多个读线程同时访问，写线程独占访问。

实战场景：配置中心数据管理

```java

public class ConfigurationCenter {

private final ReadWriteLock rwLock = new ReentrantReadWriteLock();

private Properties config = new Properties();

public String getConfig(String key) {

rwLock.readLock().lock();

try {

return config.getProperty(key);

} finally {

rwLock.readLock().unlock();

}

public void updateConfig(String key, String value) {

rwLock.writeLock().lock();

try {

config.setProperty(key, value);

persistToStorage(config);

} finally {

rwLock.writeLock().unlock();

}

```

适用场景：

- 读多写少的数据结构

- 缓存系统实现

- 配置信息管理

- 数据库连接池

### 四、Atomic原子类

java.util.concurrent.atomic包提供基于CAS操作的原子变量类，无需加锁即可实现线程安全操作。

实战场景：全局计数器

```java

public class StatisticsCounter {

private AtomicLong requestCount = new AtomicLong(0);

private AtomicInteger activeUsers = new AtomicInteger(0);

private AtomicReference latestOperation = new AtomicReference<>();

public void recordRequest() {

requestCount.incrementAndGet();

}

public boolean userLogin() {

return activeUsers.updateAndGet(current ->

current < MAX_USERS ? current + 1 : current) < MAX_USERS;

}

public void updateOperation(String operation) {

latestOperation.accumulateAndGet(operation,

(old, newOp) -> newOp + at + System.currentTimeMillis());

}

```

核心优势：

- 无锁化操作，性能极高

- 避免线程上下文切换

- 基于硬件级别的CAS指令

- 适用于计数器、状态标志等场景

### 五、CountDownLatch同步工具

CountDownLatch是强大的线程协调工具，允许一个或多个线程等待其他线程完成操作。

实战场景：分布式服务启动协调

```java

public class ServiceBootstrapper {

private final CountDownLatch latch = new CountDownLatch(3);

private final ExecutorService executor = Executors.newFixedThreadPool(3);

public void startup() throws InterruptedException {

executor.execute(this::initDatabase);

executor.execute(this::loadCache);

executor.execute(this::registerService);

// 等待所有初始化任务完成

if(latch.await(30, TimeUnit.SECONDS)) {

System.out.println(所有服务启动完成);

} else {

System.out.println(服务启动超时);

}

private void initDatabase() {

try {

// 数据库初始化逻辑

DatabasePool.init();

} finally {

latch.countDown();

}

private void loadCache() {

try {

// 缓存预热逻辑

CacheManager.preload();

} finally {

latch.countDown();

}

private void registerService() {

try {

// 服务注册逻辑

ServiceRegistry.register();

} finally {

latch.countDown();

}

```

典型应用：

- 多服务启动协调

- 并行计算结果汇总

- 测试用例中的并发控制

- 资源初始化等待

### 性能对比与选择策略

|---------|---------|---------|--------|

选择建议：

1. 简单同步需求优先考虑synchronized

2. 高性能计数场景使用Atomic原子类

3. 读多写少的数据结构采用ReadWriteLock

4. 复杂同步需求选择ReentrantLock

5. 线程协作场景使用CountDownLatch等同步器

通过合理选择并发控制策略，可以在保证线程安全的同时最大化系统吞吐量，构建高性能的Java并发应用。