Lock 和 synchronized 都是 Java 中用于实现线程同步的机制,但它们有一些重要的区别。我将通过代码示例来详细介绍这些区别。
1. 实现方式
synchronized 是 Java 的关键字,由 JVM 实现,而 Lock 是一个接口,需要手动实现。
synchronized 示例:
public class SynchronizedExample {
private int count = 0;
public synchronized void increment() {
count++;
}
}
Lock 示例:
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class LockExample {
private int count = 0;
private Lock lock = new ReentrantLock();
public void increment() {
lock.lock();
try {
count++;
} finally {
lock.unlock();
}
}
}
2. 灵活性
Lock 提供了更多的灵活性,例如尝试获取锁、可中断锁等。
尝试获取锁:
public boolean incrementIfPossible() {
if (lock.tryLock()) {
try {
count++;
return true;
} finally {
lock.unlock();
}
}
return false;
}
可中断锁:
public void incrementInterruptibly() throws InterruptedException {
lock.lockInterruptibly();
try {
count++;
} finally {
lock.unlock();
}
}
3. 公平性
ReentrantLock 可以设置为公平锁,而 synchronized 只能是非公平锁。
private Lock fairLock = new ReentrantLock(true); // 公平锁
4. 条件变量
Lock 可以绑定多个条件变量(Condition),而 synchronized 只能与一个隐含的条件变量(通过 wait/notify/notifyAll)关联。
class BoundedBuffer {
final Lock lock = new ReentrantLock();
final Condition notFull = lock.newCondition();
final Condition notEmpty = lock.newCondition();
final Object[] items = new Object[100];
int putptr, takeptr, count;
public void put(Object x) throws InterruptedException {
lock.lock();
try {
while (count == items.length)
notFull.await();
items[putptr] = x;
if (++putptr == items.length) putptr = 0;
++count;
notEmpty.signal();
} finally {
lock.unlock();
}
}
public Object take() throws InterruptedException {
lock.lock();
try {
while (count == 0)
notEmpty.await();
Object x = items[takeptr];
if (++takeptr == items.length) takeptr = 0;
--count;
notFull.signal();
return x;
} finally {
lock.unlock();
}
}
}
5. 性能
在低竞争的情况下,synchronized 可能会比 Lock 性能更好,因为 JVM 可以对 synchronized 进行优化。但在高竞争的情况下,Lock 通常能提供更好的性能。
6. 锁的状态
使用 Lock,我们可以查询锁的状态:
ReentrantLock lock = new ReentrantLock();
System.out.println("Is locked: " + lock.isLocked());
System.out.println("Is held by current thread: " + lock.isHeldByCurrentThread());
System.out.println("Queue length: " + lock.getQueueLength());
7. 读写锁
Lock 框架提供了读写锁的实现,而 synchronized 没有:
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
class ReadWriteMap<K, V> {
private final Map<K, V> map;
private final ReadWriteLock lock = new ReentrantReadWriteLock();
private final Lock r = lock.readLock();
private final Lock w = lock.writeLock();
public ReadWriteMap(Map<K, V> map) {
this.map = map;
}
public V put(K key, V value) {
w.lock();
try {
return map.put(key, value);
} finally {
w.unlock();
}
}
public V get(K key) {
r.lock();
try {
return map.get(key);
} finally {
r.unlock();
}
}
}
8. 锁升级
synchronized 支持锁的自动升级(偏向锁 -> 轻量级锁 -> 重量级锁),而 Lock 不支持。
这是 Java SE 6 引入的一项重要优化,目的是提高 synchronized 在不同并发环境下的性能。
synchronized 的锁有四种状态,会随着竞争情况逐渐升级。这四种状态是:
- 无锁状态
- 偏向锁
- 轻量级锁
- 重量级锁
下面我们详细介绍每种状态及其升级过程:
- 无锁状态
这是对象的初始状态。当一个对象刚被创建时,它处于无锁状态。
- 偏向锁
当一个线程第一次获得这个对象的锁时,会将这个线程的 ID 记录在对象的 Mark Word 中。这样,当这个线程再次请求这个对象的锁时,可以直接获得,而无需进行任何同步操作。
public class BiasedLockingExample {
private static Object lock = new Object();
public static void main(String[] args) {
synchronized (lock) {
System.out.println("First acquisition");
}
// 再次获取锁,此时应该是偏向锁
synchronized (lock) {
System.out.println("Second acquisition");
}
}
}
在这个例子中,第二次获取锁时,由于是同一个线程,所以可以直接获得偏向锁,无需其他同步操作。
- 轻量级锁
当有另一个线程尝试获取这个锁时,偏向锁就会升级为轻量级锁。轻量级锁使用 CAS (Compare and Swap) 操作来获取锁。
public class LightweightLockingExample {
private static Object lock = new Object();
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
synchronized (lock) {
System.out.println("Thread 1");
}
});
Thread t2 = new Thread(() -> {
synchronized (lock) {
System.out.println("Thread 2");
}
});
t1.start();
t2.start();
}
}
在这个例子中,两个线程都尝试获取同一个锁,这会导致偏向锁升级为轻量级锁。
- 重量级锁
如果多个线程同时竞争锁,轻量级锁就会升级为重量级锁。重量级锁会使用操作系统的互斥量来实现同步。
public class HeavyweightLockingExample {
private static Object lock = new Object();
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread(() -> {
synchronized (lock) {
System.out.println(Thread.currentThread().getName() + " acquired lock");
try {
Thread.sleep(100); // 模拟持有锁一段时间
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
}
}
在这个例子中,我们创建了 10 个线程同时竞争同一个锁。这种高度竞争的情况会导致锁迅速升级为重量级锁。
锁升级的过程是不可逆的,也就是说,一旦锁升级到某个级别,就不会再降级。这是为了避免频繁的锁状态切换带来的性能开销。
JVM 参数设置:
- 可以使用
-XX:+UseBiasedLocking
开启偏向锁(默认开启) - 使用
-XX:-UseBiasedLocking
关闭偏向锁 - 使用
-XX:BiasedLockingStartupDelay=0
设置偏向锁的启动延迟
监控锁的状态:
可以使用 JVM 的 -XX:+PrintFlagsFinal
参数来查看偏向锁的状态,或者使用 JConsole 或 VisualVM 等工具来监控锁的状态。
总结:
synchronized 的锁升级机制是一个自适应的过程,它会根据实际的竞争情况自动选择最合适的锁实现。这种机制大大提高了 synchronized 在各种场景下的性能,使得 synchronized 在许多情况下的性能可以与 Lock 接口的实现相媲美,同时保持了使用的简单性。