Java 同步锁 synchronized 性能下降与锁膨胀的底层原因分析
大家好，今天我们来聊聊 Java 中 synchronized 锁，这个看似简单的关键字，在并发编程中却经常成为性能瓶颈的罪魁祸首。我们会深入分析 synchronized 导致性能下降的原因，以及锁膨胀的底层机制，并结合代码实例，帮助大家更好地理解和使用它。
1. synchronized 的基本概念和工作原理
synchronized 是 Java 中用于实现线程同步的关键字，它可以保证在同一时刻，只有一个线程可以执行被 synchronized 修饰的代码块或方法。它的基本工作原理是基于 Monitor 对象 (也称为锁对象)。
-
Monitor 对象: 每一个 Java 对象都关联着一个 Monitor 对象。Monitor 对象包含了锁信息、持有锁的线程信息以及等待锁的线程队列。
-
加锁和解锁: 当一个线程尝试进入
synchronized代码块时，它会尝试获取对应对象的 Monitor 锁。如果锁未被占用，线程成功获取锁并进入代码块；如果锁已被其他线程占用，则该线程会被阻塞并加入到 Monitor 对象的等待队列中。当持有锁的线程执行完synchronized代码块后，它会释放锁，并唤醒等待队列中的一个或多个线程，让它们竞争锁。
synchronized 可以修饰实例方法、静态方法和代码块：
-
实例方法: 锁对象是
this，即当前实例对象。public class MyClass { public synchronized void myMethod() { // 同步代码 } } -
静态方法: 锁对象是
MyClass.class，即该类的 Class 对象。public class MyClass { public static synchronized void myStaticMethod() { // 同步代码 } } -
代码块: 需要显式指定锁对象。
public class MyClass { private Object lock = new Object(); public void myMethod() { synchronized (lock) { // 同步代码 } } }
2. synchronized 导致性能下降的原因
synchronized 带来的性能下降主要体现在以下几个方面：
-
阻塞和唤醒的开销: 当多个线程竞争同一个锁时，未获得锁的线程会被阻塞，需要操作系统的介入进行线程上下文切换。线程上下文切换是一个昂贵的操作，包括保存和恢复 CPU 寄存器、堆栈指针以及程序计数器等。此外，当锁被释放后，需要唤醒等待队列中的线程，这也会带来额外的开销。
-
锁竞争: 锁竞争越激烈，性能下降越明显。如果大部分时间只有一个线程持有锁，那么
synchronized的开销相对较小；但如果多个线程频繁地争夺锁，阻塞和唤醒的开销就会显著增加，导致程序性能下降。 -
上下文切换: 线程阻塞会引起上下文切换，线程从运行态变为阻塞态，需要保存当前线程的 CPU 寄存器、堆栈等信息，然后切换到另一个线程执行。当被阻塞的线程被唤醒后，需要恢复之前保存的上下文信息，这期间会消耗大量的 CPU 时间。
-
死锁: 不合理的锁使用可能会导致死锁，多个线程互相等待对方释放锁，导致程序无法继续执行。
-
锁的粒度: 如果锁的粒度过大，会导致大量的线程阻塞，即使这些线程实际上并不需要访问共享资源，也会被阻塞等待锁的释放。
代码示例：锁竞争导致的性能下降
public class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
public int getCount() {
return count;
}
public static void main(String[] args) throws InterruptedException {
Counter counter = new Counter();
int numThreads = 10;
int iterations = 100000;
Thread[] threads = new Thread[numThreads];
long startTime = System.currentTimeMillis();
for (int i = 0; i < numThreads; i++) {
threads[i] = new Thread(() -> {
for (int j = 0; j < iterations; j++) {
counter.increment();
}
});
threads[i].start();
}
for (int i = 0; i < numThreads; i++) {
threads[i].join();
}
long endTime = System.currentTimeMillis();
System.out.println("Count: " + counter.getCount());
System.out.println("Time taken: " + (endTime - startTime) + " ms");
}
}在这个例子中，多个线程并发地调用 increment() 方法，由于 increment() 方法使用了 synchronized 关键字，因此只有一个线程可以同时执行该方法。当线程数量增加时，锁竞争会变得更加激烈，导致性能下降。
3. 锁膨胀的底层机制
为了优化 synchronized 的性能，Java 虚拟机 (JVM) 引入了锁膨胀机制。锁膨胀指的是锁的状态会随着竞争的激烈程度而升级，从无锁状态到偏向锁、轻量级锁，最后升级到重量级锁。这种机制旨在减少锁竞争带来的开销。
-
无锁 (Unlocked): 初始状态，没有任何线程持有锁。
-
偏向锁 (Biased Locking): 当只有一个线程访问同步块时，该线程会自动获得偏向锁。偏向锁会偏向于第一个访问它的线程，在后续的运行过程中，如果该线程再次访问该同步块，则不需要进行任何同步操作，从而减少了锁竞争的开销。
-
原理: 在对象头的 Mark Word 中记录获得锁的线程 ID。当线程再次进入同步块时，检查 Mark Word 中的线程 ID 是否为当前线程，如果是，则直接进入同步块；否则，尝试撤销偏向锁。
-
适用场景: 只有一个线程访问同步块的场景。
-
-
轻量级锁 (Lightweight Locking): 当多个线程尝试访问同步块，但只有一个线程获得偏向锁时，其他线程会尝试使用 CAS (Compare and Swap) 操作来获取锁。如果 CAS 操作成功，则线程获得轻量级锁；否则，线程会自旋等待锁的释放。
-
原理: 线程在自己的栈帧中创建一个锁记录 (Lock Record)，并将对象头的 Mark Word 复制到锁记录中。然后，线程尝试使用 CAS 操作将对象头的 Mark Word 更新为指向锁记录的指针。如果 CAS 操作成功，则线程获得轻量级锁；否则，表示存在锁竞争，线程会自旋等待锁的释放。
-
适用场景: 多个线程竞争锁，但竞争不激烈的场景。
-
-
重量级锁 (Heavyweight Locking): 当线程自旋达到一定的次数后，仍然无法获得锁，或者有其他线程已经持有锁，则锁会升级为重量级锁。重量级锁会阻塞未获得锁的线程，并将它们加入到 Monitor 对象的等待队列中，等待锁的释放。
-
原理: 使用操作系统的互斥量 (Mutex) 来实现锁的互斥访问。未获得锁的线程会被阻塞，需要操作系统的介入进行线程上下文切换。
-
适用场景: 多个线程竞争锁，且竞争激烈的场景。
-
锁膨胀的过程:
无锁 -> 偏向锁 -> 轻量级锁 -> 重量级锁
锁降级: 锁只能升级，不能降级。这是为了避免频繁的锁状态切换带来的开销。
锁膨胀的优势:
- 减少锁竞争的开销: 在不同的竞争情况下，使用不同的锁机制，从而减少锁竞争带来的开销。
- 提高程序性能: 通过锁膨胀机制，可以根据实际的竞争情况动态地调整锁的策略，从而提高程序的整体性能。
代码示例：锁膨胀的模拟 (简化版)
public class LockEscalation {
static Object lock = new Object();
public static void main(String[] args) throws InterruptedException {
// 模拟单线程访问，偏向锁
synchronized (lock) {
System.out.println("偏向锁：单线程访问");
}
Thread t1 = new Thread(() -> {
synchronized (lock) {
System.out.println("轻量级锁：线程1访问");
try {
Thread.sleep(100); // 模拟持有锁一段时间
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
Thread t2 = new Thread(() -> {
synchronized (lock) {
System.out.println("重量级锁：线程2访问，竞争激烈");
}
});
t1.start();
Thread.sleep(10); // 保证t1先获取锁
t2.start();
t1.join();
t2.join();
System.out.println("程序结束");
}
}这个例子只是一个简化的模拟，实际上 JVM 会自动进行锁膨胀，我们无法直接观察到锁状态的变化。但是，通过这个例子，我们可以理解锁膨胀的基本概念。
4. 如何优化 synchronized 的使用
-
减小锁的粒度: 尽量缩小
synchronized代码块的范围，只对需要同步的共享资源进行加锁。可以使用 锁分离 和 分段锁 等技术来减小锁的粒度。-
锁分离: 将不同的资源分别使用不同的锁来保护。例如，
ConcurrentHashMap使用了锁分离技术，将整个 Map 分成多个 Segment，每个 Segment 拥有自己的锁，从而允许多个线程同时访问不同的 Segment。 -
分段锁: 将一个资源分成多个段，每个段拥有自己的锁。例如，
LongAdder使用了分段锁技术，将一个 long 类型的计数器分成多个 Cell，每个 Cell 拥有自己的锁，从而允许多个线程同时更新不同的 Cell。
-
-
使用读写锁 (ReadWriteLock): 当读操作远多于写操作时，可以使用读写锁来提高程序的并发性能。读写锁允许多个线程同时进行读操作，但只允许一个线程进行写操作。
-
使用原子类 (Atomic Classes):
java.util.concurrent.atomic包提供了很多原子类，可以实现无锁的并发操作。原子类使用 CAS 操作来保证线程安全，避免了阻塞和唤醒的开销。 -
避免长时间持有锁: 尽量减少
synchronized代码块的执行时间，避免长时间持有锁，从而减少其他线程的等待时间。 -
使用 Lock 接口:
java.util.concurrent.locks包提供了 Lock 接口及其实现类，例如ReentrantLock。 Lock 接口提供了比synchronized更加灵活的锁机制，例如可以中断等待锁的线程、可以设置锁的超时时间等。 -
尽量使用局部变量: 避免在
synchronized代码块中访问共享变量，尽量使用局部变量来减少锁竞争。 -
了解锁的膨胀机制: 理解锁的膨胀机制，可以帮助我们更好地选择合适的锁策略，避免不必要的锁竞争。
代码示例：使用原子类优化计数器
import java.util.concurrent.atomic.AtomicInteger;
public class AtomicCounter {
private AtomicInteger count = new AtomicInteger(0);
public void increment() {
count.incrementAndGet();
}
public int getCount() {
return count.get();
}
public static void main(String[] args) throws InterruptedException {
AtomicCounter counter = new AtomicCounter();
int numThreads = 10;
int iterations = 100000;
Thread[] threads = new Thread[numThreads];
long startTime = System.currentTimeMillis();
for (int i = 0; i < numThreads; i++) {
threads[i] = new Thread(() -> {
for (int j = 0; j < iterations; j++) {
counter.increment();
}
});
threads[i].start();
}
for (int i = 0; i < numThreads; i++) {
threads[i].join();
}
long endTime = System.currentTimeMillis();
System.out.println("Count: " + counter.getCount());
System.out.println("Time taken: " + (endTime - startTime) + " ms");
}
}在这个例子中，我们使用了 AtomicInteger 类来实现计数器，避免了使用 synchronized 关键字带来的阻塞和唤醒的开销，从而提高了程序的并发性能。
5. 总结：选择正确的同步方式
选择合适的同步方式对于程序的性能至关重要。synchronized 关键字虽然简单易用，但在高并发场景下可能会导致性能瓶颈。我们需要根据实际的竞争情况，选择合适的锁策略，例如减小锁的粒度、使用读写锁、使用原子类等。理解锁膨胀的机制，可以帮助我们更好地优化 synchronized 的使用，提高程序的整体性能。
6. 深入理解才能更好地使用
synchronized 锁是 Java 并发编程的重要组成部分，但也需要谨慎使用。理解其工作原理、性能瓶颈以及锁膨胀机制，才能在实际开发中做出正确的选择，避免不必要的性能损失，编写出高效、稳定的并发程序。