Java并发编程：精细化你的锁，提升并发性能
大家好，今天我们来聊聊Java并发编程中的一个常见问题：锁的粒度过大。很多时候，为了保证线程安全，我们很自然地会使用锁。但是，如果锁的粒度控制不当，尤其是锁的范围过大，很容易导致性能瓶颈和激烈的锁竞争，反而降低了程序的并发能力。
想象一下，如果所有人都必须排队使用同一个打印机，即使有些人只是打印一页纸，其他人也只能等待。这就像一个粒度过大的锁，即使某些线程只需要访问一小部分资源，其他线程也必须等待锁释放。
那么，如何避免这个问题，精细化我们的锁，从而提升并发性能呢？接下来，我将从多个方面深入探讨这个问题。
1. 什么是锁的粒度？
锁的粒度指的是锁保护的数据范围的大小。
- 粗粒度锁: 保护的数据范围较大，例如，锁住整个对象或者整个方法。
- 细粒度锁: 保护的数据范围较小，例如，只锁住对象的某个字段或者某个代码块。
2. 锁粒度过大带来的问题
- 性能瓶颈: 多个线程争用同一个锁，导致大量线程阻塞，降低了系统的吞吐量。
- 竞争加剧: 更多的线程参与锁的竞争，增加了上下文切换的开销。
- 可伸缩性差: 当并发量增加时，粗粒度锁的性能下降更加明显，系统难以扩展。
3. 如何判断锁的粒度是否过大？
- 观察线程状态: 使用
jstack命令或者VisualVM等工具，观察线程的运行状态，如果发现大量线程处于BLOCKED状态，并且这些线程都阻塞在同一个锁上，那么很可能锁的粒度过大。 - 性能监控: 使用性能监控工具，例如JConsole或者Arthas，监控系统的CPU利用率、线程数、锁的等待时间等指标。如果CPU利用率不高，但是线程数很高，并且锁的等待时间很长，那么很可能存在锁竞争问题。
- 代码审查: 仔细审查代码，分析锁保护的数据范围是否合理。是否存在过度保护的情况？
4. 降低锁粒度的方法
接下来，我们重点介绍几种常用的降低锁粒度的方法。
4.1. 锁分解
锁分解是指将一个锁分解成多个锁，每个锁保护不同的数据。这样，不同的线程可以同时访问不同的数据，从而提高并发性。
案例：ConcurrentHashMap
ConcurrentHashMap是Java并发包中一个非常优秀的例子，它使用了锁分段技术，将整个Map分成多个Segment，每个Segment相当于一个小的HashMap，拥有自己的锁。这样，当多个线程访问不同的Segment时，它们可以并发执行，而不需要等待同一个锁。
public class ConcurrentHashMap<K,V> extends AbstractMap<K,V>
implements ConcurrentMap<K,V>, Serializable {
/**
* The segments, each of which is a specialized hash table.
*/
final Segment<K,V>[] segments;
static final class Segment<K,V> extends ReentrantLock implements Serializable {
// ... Segment内部实现细节 ...
}
// ... 其他成员变量和方法 ...
}在ConcurrentHashMap中，segments数组存储了多个Segment对象，每个Segment对象都继承了ReentrantLock，拥有自己的锁。当一个线程需要访问某个键值对时，它首先根据键的哈希值找到对应的Segment，然后获取该Segment的锁。
4.2. 锁分离
锁分离是指将读锁和写锁分离，允许多个线程同时读取数据，只有一个线程可以写入数据。这可以显著提高读多写少场景下的并发性能。
案例：ReadWriteLock
Java提供了ReadWriteLock接口，以及其实现类ReentrantReadWriteLock，用于实现读写锁分离。
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class DataContainer {
private Object data;
private final ReadWriteLock lock = new ReentrantReadWriteLock();
public Object readData() {
lock.readLock().lock();
try {
// 读取数据的操作
return data;
} finally {
lock.readLock().unlock();
}
}
public void writeData(Object newData) {
lock.writeLock().lock();
try {
// 写入数据的操作
this.data = newData;
} finally {
lock.writeLock().unlock();
}
}
}在这个例子中，readData()方法获取读锁，允许多个线程同时读取数据。writeData()方法获取写锁，只允许一个线程写入数据。
表格：ReadWriteLock的特性
| 特性 | 描述 |
|---|---|
| 读锁 | 可以被多个线程同时持有，允许多个线程并发读取数据。 |
| 写锁 | 只能被一个线程持有，独占访问数据，防止数据不一致。 |
| 锁降级 | 允许持有写锁的线程降级为读锁，例如，在写入数据后，需要立即读取数据进行验证。 |
| 锁升级 | 不允许从读锁直接升级为写锁，因为这可能导致死锁。需要先释放读锁，然后尝试获取写锁。 |
| 适用场景 | 读多写少的场景，例如，缓存系统、配置中心等。 |
4.3. 使用原子变量
原子变量提供了一种轻量级的线程安全机制，它们使用CAS (Compare and Swap) 操作来保证原子性，避免了使用锁的开销。
案例：AtomicInteger
Java提供了AtomicInteger类，用于实现原子性的整数操作。
import java.util.concurrent.atomic.AtomicInteger;
public class Counter {
private AtomicInteger count = new AtomicInteger(0);
public int increment() {
return count.incrementAndGet();
}
public int getCount() {
return count.get();
}
}在这个例子中，increment()方法使用incrementAndGet()方法来原子性地增加计数器的值，避免了使用锁的开销。
表格：AtomicInteger与synchronized的比较
| 特性 | AtomicInteger | synchronized |
|---|---|---|
| 实现方式 | CAS (Compare and Swap) | 互斥锁 |
| 开销 | 较低，避免了线程阻塞和上下文切换。 | 较高，可能导致线程阻塞和上下文切换。 |
| 适用场景 | 简单的原子操作，例如，计数器、标志位等。 | 复杂的同步操作，需要保护多个变量或者代码块。 |
| 竞争激烈程度 | 竞争不激烈时，性能优于synchronized。 | 竞争激烈时，性能可能不如synchronized。 |
4.4. 使用ThreadLocal
ThreadLocal为每个线程提供了一个独立的变量副本，线程可以访问自己的副本，而不需要与其他线程共享变量。这可以避免线程安全问题，并且提高并发性能。
案例：SimpleDateFormat
SimpleDateFormat类不是线程安全的，如果多个线程同时使用同一个SimpleDateFormat对象，可能会导致数据错误。可以使用ThreadLocal来解决这个问题。
import java.text.DateFormat;
import java.text.SimpleDateFormat;
public class DateFormatThreadLocal {
private static final ThreadLocal<DateFormat> dateFormatThreadLocal =
ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
public static DateFormat getDateFormat() {
return dateFormatThreadLocal.get();
}
}在这个例子中，dateFormatThreadLocal为每个线程提供了一个独立的SimpleDateFormat对象。当线程第一次调用getDateFormat()方法时，ThreadLocal会创建一个新的SimpleDateFormat对象，并将其存储在线程的本地存储中。后续的调用将直接返回线程本地存储中的对象。
4.5. 减少锁的持有时间
尽量缩短锁的持有时间，只在必要的时候才获取锁，并在完成操作后立即释放锁。
- 缩小同步代码块的范围: 只将需要同步的代码放在
synchronized块中，避免过度保护。 - 使用try-finally块确保锁的释放: 即使发生异常，也要确保锁能够被正确释放。
- 避免在同步代码块中进行耗时操作: 如果同步代码块中包含耗时操作，例如，I/O操作或者网络请求，那么会大大增加锁的持有时间，降低并发性能。可以将这些耗时操作移到同步代码块之外。
4.6. 使用无锁数据结构
Java并发包提供了一些无锁数据结构，例如，ConcurrentLinkedQueue、ConcurrentSkipListMap等。这些数据结构使用CAS操作来实现线程安全，避免了使用锁的开销。
案例：ConcurrentLinkedQueue
ConcurrentLinkedQueue是一个线程安全的无锁队列，它使用CAS操作来实现元素的入队和出队。
import java.util.concurrent.ConcurrentLinkedQueue;
public class MessageQueue {
private final ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<>();
public void enqueue(String message) {
queue.offer(message);
}
public String dequeue() {
return queue.poll();
}
}在这个例子中，enqueue()方法使用offer()方法将元素添加到队列的尾部，dequeue()方法使用poll()方法从队列的头部移除元素。这两个方法都是线程安全的，并且不需要使用锁。
5. 选择合适的锁
Java提供了多种类型的锁，例如，ReentrantLock、ReentrantReadWriteLock、StampedLock等。不同的锁适用于不同的场景。
- ReentrantLock: 可重入锁，支持公平锁和非公平锁。
- ReentrantReadWriteLock: 读写锁，允许多个线程同时读取数据，只有一个线程可以写入数据。
- StampedLock: JDK 8引入的一种新的读写锁，提供了更灵活的锁模式，可以避免读写锁的饥饿问题。
表格：各种锁的比较
| 锁类型 | 特性 | 适用场景 |
|---|---|---|
synchronized |
JVM内置锁，简单易用，但是功能相对有限。 | 简单的同步场景，例如，保护少量共享变量。 |
ReentrantLock |
可重入锁，支持公平锁和非公平锁，可以中断等待锁的线程，提供了更灵活的锁控制。 | 需要更灵活的锁控制，例如，需要中断等待锁的线程，或者需要使用公平锁。 |
ReentrantReadWriteLock |
读写锁，允许多个线程同时读取数据，只有一个线程可以写入数据。 | 读多写少的场景，例如，缓存系统、配置中心等。 |
StampedLock |
JDK 8引入的一种新的读写锁，提供了更灵活的锁模式，可以避免读写锁的饥饿问题。支持乐观读模式，在读取数据时不需要获取锁，只有在写入数据时才需要获取锁。 | 读多写少，且对性能要求非常高的场景，例如，某些缓存系统。 |
6. 避免死锁
死锁是指两个或多个线程互相等待对方释放锁，导致所有线程都无法继续执行的情况。
- 避免循环等待: 确保线程获取锁的顺序一致，避免循环等待。
- 设置超时时间: 在获取锁时设置超时时间，如果超过超时时间仍然无法获取锁，则放弃获取，避免长时间等待。
- 使用tryLock()方法:
tryLock()方法尝试获取锁，如果获取成功则返回true，否则返回false。可以使用tryLock()方法来避免死锁。
案例：死锁的例子
public class DeadlockExample {
private static final Object lock1 = new Object();
private static final Object lock2 = new Object();
public static void main(String[] args) {
Thread thread1 = new Thread(() -> {
synchronized (lock1) {
System.out.println("Thread 1: Holding lock 1...");
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread 1: Waiting for lock 2...");
synchronized (lock2) {
System.out.println("Thread 1: Holding lock 1 & 2...");
}
}
});
Thread thread2 = new Thread(() -> {
synchronized (lock2) {
System.out.println("Thread 2: Holding lock 2...");
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread 2: Waiting for lock 1...");
synchronized (lock1) {
System.out.println("Thread 2: Holding lock 1 & 2...");
}
}
});
thread1.start();
thread2.start();
}
}在这个例子中，线程1先获取lock1，然后尝试获取lock2。线程2先获取lock2，然后尝试获取lock1。由于线程1和线程2互相等待对方释放锁，导致死锁。
7. 使用并发工具类
Java并发包提供了很多有用的并发工具类，例如，CountDownLatch、CyclicBarrier、Semaphore等。这些工具类可以简化并发编程的复杂性，提高开发效率。
- CountDownLatch: 允许一个或多个线程等待其他线程完成操作。
- CyclicBarrier: 允许一组线程互相等待，直到所有线程都到达某个屏障点。
- Semaphore: 控制对共享资源的访问，限制同时访问资源的线程数量。
案例：CountDownLatch
import java.util.concurrent.CountDownLatch;
public class TaskExecutor {
public static void main(String[] args) throws InterruptedException {
int taskCount = 3;
CountDownLatch latch = new CountDownLatch(taskCount);
for (int i = 0; i < taskCount; i++) {
new Thread(() -> {
try {
// 执行任务
System.out.println("Task " + Thread.currentThread().getName() + " is running...");
Thread.sleep(1000);
System.out.println("Task " + Thread.currentThread().getName() + " is finished.");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
latch.countDown(); // 任务完成，计数器减1
}
}).start();
}
latch.await(); // 等待所有任务完成
System.out.println("All tasks are finished.");
}
}在这个例子中，CountDownLatch用于等待所有任务完成。每个任务完成后，调用countDown()方法将计数器减1。主线程调用await()方法等待计数器变为0，表示所有任务都已完成。
关键点的概括
- 选择合适的锁粒度是优化并发性能的关键。
- 锁分解、锁分离、原子变量、ThreadLocal等技术可以降低锁的粒度。
- 避免死锁，合理使用并发工具类可以简化并发编程。
- 根据实际场景选择合适的锁类型，并进行性能测试和调优。
希望今天的分享能够帮助大家更好地理解和应用Java并发编程中的锁优化技术。谢谢大家！