一、并发与并行：概念与应用场景
作为一名 Java 开发七年的老兵，我深知并发编程是 Java 体系中最具挑战性但也最有价值的领域之一。在深入探讨锁机制和原子类之前，我们先明确两个基本概念：
并发（Concurrency） ：指多个任务在同一时间段内交替执行，通常在单核 CPU 上通过时间片轮转实现。典型场景如 Web 服务器处理多个请求，通过线程池复用线程资源。
并行（Parallelism） ：指多个任务在同一时刻真正同时执行，依赖多核 CPU 的硬件支持。典型场景如科学计算、大数据处理中的并行计算框架。
理解这两个概念的区别对后续技术选型至关重要。在实际项目中，我们常需要根据业务场景选择合适的并发模型。
二、锁机制：从理论到实践
1. 锁的基本概念与分类
锁是并发编程的核心工具，用于控制多个线程对共享资源的访问。Java 中的锁主要分为两类：
- 内置锁（Intrinsic Lock） ：通过synchronized关键字实现
- 显式锁（Explicit Lock） ：通过java.util.concurrent.locks包中的接口和类实现
锁的核心特性包括：互斥性、可重入性、公平性和锁粒度。理解这些特性是合理使用锁的基础。
2. ReentrantLock 详解与实战
在实际项目中，我更倾向于使用ReentrantLock而非synchronized，因为它提供了更灵活的锁控制能力。以下是一个典型的使用场景：
import java.util.concurrent.locks.ReentrantLock;
/**
* 商品库存管理系统 - 使用ReentrantLock实现线程安全
*/
public class InventoryManager {
private final ReentrantLock lock = new ReentrantLock();
private int stock;
public InventoryManager(int initialStock) {
this.stock = initialStock;
}
/**
* 增加库存 - 支持并发操作
*/
public void addStock(int quantity) {
lock.lock(); // 加锁
try {
// 业务逻辑：检查库存上限等
stock += quantity;
System.out.println(Thread.currentThread().getName() + " 增加库存成功，当前库存: " + stock);
} finally {
lock.unlock(); // 释放锁，必须在finally块中执行
}
}
/**
* 扣减库存 - 使用tryLock避免长时间等待
*/
public boolean reduceStock(int quantity) {
// 尝试获取锁，等待1秒
try {
if (lock.tryLock(1, java.util.concurrent.TimeUnit.SECONDS)) {
try {
if (stock >= quantity) {
stock -= quantity;
System.out.println(Thread.currentThread().getName() + " 扣减库存成功，当前库存: " + stock);
return true;
} else {
System.out.println(Thread.currentThread().getName() + " 库存不足，扣减失败");
return false;
}
} finally {
lock.unlock();
}
} else {
System.out.println(Thread.currentThread().getName() + " 获取锁超时，操作失败");
return false;
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
return false;
}
}
}
这个例子展示了ReentrantLock的几个关键特性：
- 手动加锁和解锁，需在 finally 块中释放锁
- 支持tryLock()方法实现非阻塞锁获取
- 可设置锁超时时间，避免线程长时间阻塞
- 相比synchronized，提供了更细粒度的锁控制
3. ReentrantLock 与 synchronized 的对比
在实际开发中，我们需要根据场景选择合适的锁机制。以下是两者的对比总结：
|
特性 |
synchronized |
ReentrantLock |
|
锁实现方式 |
JVM 内置机制 |
Java API 实现 |
|
锁释放机制 |
自动释放（方法 / 代码块结束） |
手动释放（需在 finally 中调用） |
|
可中断性 |
不可中断 |
可中断（lockInterruptibly） |
|
超时机制 |
不支持 |
支持 tryLock (timeout) |
|
公平性 |
非公平 |
可配置公平 / 非公平 |
|
条件变量 |
单一 wait/notify |
支持多个 Condition 对象 |
在高并发场景下，ReentrantLock通常能提供更好的性能和灵活性，尤其是需要实现复杂的锁逻辑时。
三、线程安全集合：从传统方案到 JUC 包的演进
1. 线程安全问题与传统解决方案
当多个线程同时操作共享集合时，会引发线程安全问题。最典型的例子是多个线程同时对 HashMap 进行读写操作：
import java.util.HashMap;
import java.util.Map;
/**
* 非线程安全的HashMap示例 - 会导致ConcurrentModificationException
*/
public class HashMapMultiThreadDemo {
private static Map<String, Integer> map = new HashMap<>();
public static void main(String[] args) throws InterruptedException {
// 线程1：不断写入数据
Thread writer = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
map.put("key" + i, i);
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
// 线程2：不断读取数据
Thread reader = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
// 这里可能会抛出ConcurrentModificationException
System.out.println(map.get("key" + i));
}
});
writer.start();
reader.start();
writer.join();
reader.join();
}
}
传统的解决方案是使用Collections.synchronizedMap()：
Map<String, Integer> synchronizedMap = Collections.synchronizedMap(new HashMap<>());
这种方式虽然解决了线程安全问题，但性能较差，因为它使用了全局锁，所有操作都需要串行执行。
2. JUC 包中的高性能线程安全集合
在实际项目中，我们更推荐使用 JUC 包中的线程安全集合。以下是几个典型场景和对应的实现：
（1）高并发读写的 Map - ConcurrentHashMap
import java.util.concurrent.ConcurrentHashMap;
/**
* 使用ConcurrentHashMap实现高并发缓存
*/
public class CacheService {
private final ConcurrentHashMap<String, Object> cache = new ConcurrentHashMap<>();
/**
* 获取缓存数据
*/
public Object get(String key) {
return cache.get(key);
}
/**
* 放入缓存数据（如果不存在）
*/
public void putIfAbsent(String key, Object value) {
// 使用putIfAbsent避免重复计算
cache.putIfAbsent(key, value);
}
/**
* 移除缓存数据
*/
public void remove(String key) {
cache.remove(key);
}
}
ConcurrentHashMap在 JDK8 中进行了重大优化，采用 CAS + synchronized 实现，锁粒度更小，性能显著提升。
（2）读写分离的场景 - CopyOnWriteArrayList
import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;
/**
* 使用CopyOnWriteArrayList实现配置中心
*/
public class ConfigCenter {
private final CopyOnWriteArrayList<String> listeners = new CopyOnWriteArrayList<>();
/**
* 注册监听器
*/
public void registerListener(String listener) {
listeners.add(listener);
}
/**
* 广播配置变更
*/
public void broadcastConfigChange(String config) {
// 遍历过程中允许其他线程修改list
Iterator<String> it = listeners.iterator();
while (it.hasNext()) {
String listener = it.next();
System.out.println("向监听器 " + listener + " 广播配置变更: " + config);
}
}
}
CopyOnWriteArrayList适合读多写少的场景，读操作无锁，写操作时复制数组，保证线程安全的同时不影响读性能。
四、原子类：无锁编程的利器
1. 原子类的基本原理与应用场景
原子类是基于 CAS（Compare-And-Swap）操作实现的无锁线程安全类，位于java.util.concurrent.atomic包下。CAS 操作包含三个操作数：内存位置（V）、预期原值（A）和新值（B）。当且仅当 V 的值等于 A 时，CAS 才会通过原子方式用新值 B 来更新 V 的值。
原子类的典型应用场景包括：计数器、序列号生成器、分布式 ID 生成等。
2. 实战案例：高性能 ID 生成器
import java.util.concurrent.atomic.AtomicLong;
/**
* 使用AtomicLong实现高性能分布式ID生成器
*/
public class IdGenerator {
private static final AtomicLong ID_SEQUENCE = new AtomicLong(0);
private static final long MAX_ID = 1000000000L;
/**
* 生成下一个唯一ID
*/
public static long nextId() {
// 使用循环CAS确保生成唯一ID
long current, next;
do {
current = ID_SEQUENCE.get();
next = (current >= MAX_ID) ? 0 : current + 1;
} while (!ID_SEQUENCE.compareAndSet(current, next));
return next;
}
}
这个 ID 生成器使用AtomicLong实现，避免了传统锁机制的性能开销，适合高并发场景下的 ID 生成需求。
3. 原子类与锁的性能对比
在高并发场景下，原子类的性能通常优于锁机制。以下是一个简单的性能对比测试：
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;
/**
* 原子类与synchronized性能对比测试
*/
public class PerformanceComparison {
private static final int THREAD_COUNT = 100;
private static final int OPS_PER_THREAD = 100000;
public static void main(String[] args) throws InterruptedException {
testSynchronized();
testAtomic();
}
private static void testSynchronized() throws InterruptedException {
CountDownLatch latch = new CountDownLatch(THREAD_COUNT);
SynchronizedCounter counter = new SynchronizedCounter();
long startTime = System.currentTimeMillis();
for (int i = 0; i < THREAD_COUNT; i++) {
new Thread(() -> {
for (int j = 0; j < OPS_PER_THREAD; j++) {
counter.increment();
}
latch.countDown();
}).start();
}
latch.await();
long endTime = System.currentTimeMillis();
System.out.println("Synchronized: " + counter.get() + " ops, time: " + (endTime - startTime) + "ms");
}
private static void testAtomic() throws InterruptedException {
CountDownLatch latch = new CountDownLatch(THREAD_COUNT);
AtomicCounter counter = new AtomicCounter();
long startTime = System.currentTimeMillis();
for (int i = 0; i < THREAD_COUNT; i++) {
new Thread(() -> {
for (int j = 0; j < OPS_PER_THREAD; j++) {
counter.increment();
}
latch.countDown();
}).start();
}
latch.await();
long endTime = System.currentTimeMillis();
System.out.println("Atomic: " + counter.get() + " ops, time: " + (endTime - startTime) + "ms");
}
static class SynchronizedCounter {
private int count = 0;
public synchronized void increment() {
count++;
}
public synchronized int get() {
return count;
}
}
static class AtomicCounter {
private AtomicInteger count = new AtomicInteger(0);
public void increment() {
count.incrementAndGet();
}
public int get() {
return count.get();
}
}
}
在我的测试环境中，原子类的性能通常比 synchronized 快 3-5 倍，特别是在高并发场景下差距更明显。
五、并发编程最佳实践总结
作为一名有多年 Java 开发经验的工程师，我总结了以下并发编程最佳实践：
- 优先使用 JUC 包中的工具类：避免手动实现锁机制，优先使用ConcurrentHashMap、CopyOnWriteArrayList等成熟的并发集合。
- 尽量使用原子类替代锁：对于简单的原子操作（如计数、累加），优先使用AtomicInteger、AtomicLong等原子类，性能更高。
- 合理选择锁的粒度：使用细粒度锁替代粗粒度锁，减少锁竞争。例如，使用分段锁或对象锁替代类锁。
- 避免死锁和锁饥饿：
- 保持锁的获取顺序一致
- 使用带超时的锁获取方法
- 考虑使用公平锁（虽然性能略低，但可避免线程饥饿）
- 对锁进行性能测试：在高并发场景下，不同锁实现的性能差异可能很大，建议进行压测后再做选择。
- 遵循开放调用原则：在持有锁的期间，避免调用外部方法，减少锁持有时间。
- 使用线程池管理线程：避免手动创建和销毁线程，使用ExecutorService创建线程池，提高线程复用率。
扫一扫
768
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
