Java的锁机制详解

在并发编程中，锁是用于控制多个线程对共享资源进行访问的工具。Java提供了多种锁机制，从最基础的 synchronized 到高级的 ReentrantLock，这些锁帮助我们确保线程安全，并能有效避免数据竞争和死锁问题。
在这里插入图片描述

1. synchronized 关键字

synchronized 是Java中最简单的锁机制。它可以锁住方法或者代码块，确保某个线程在访问共享资源时，其他线程无法访问同一个资源。

示例代码：同步方法

java">public class SynchronizedExample {public synchronized void synchronizedMethod() {System.out.println("Thread " + Thread.currentThread().getName() + " is executing synchronized method.");}
}

在上述代码中，synchronizedMethod 方法被 synchronized 关键字修饰，意味着同一时间只能有一个线程执行该方法。

示例代码：同步代码块

java">public class SynchronizedBlockExample {private final Object lock = new Object();public void synchronizedBlock() {synchronized (lock) {System.out.println("Thread " + Thread.currentThread().getName() + " is executing synchronized block.");}}
}

使用同步代码块可以灵活地锁定某个对象（如上例中的 lock），只锁住需要保护的部分，而不是整个方法。

锁的粒度问题

synchronized 锁的粒度较粗，可能会导致性能瓶颈。对于更复杂的并发场景，ReentrantLock 等更灵活的锁机制是更好的选择。

2. ReentrantLock

ReentrantLock 是 Java java.util.concurrent.locks 包中的高级锁，它提供了更丰富的功能，如：公平锁、可重入性、可中断锁 等。

2.1 基本使用

java">import java.util.concurrent.locks.ReentrantLock;public class ReentrantLockExample {private final ReentrantLock lock = new ReentrantLock();public void execute() {lock.lock(); // 获取锁try {System.out.println("Thread " + Thread.currentThread().getName() + " is executing.");} finally {lock.unlock(); // 释放锁}}
}

在这个例子中，我们显式地调用 lock.lock() 来获取锁，并在 finally 中确保锁会被释放，以防止因异常导致死锁。

2.2 公平锁

默认情况下，ReentrantLock 是非公平锁，即等待时间长的线程不一定优先获得锁。你可以通过构造函数指定是否为公平锁：

java">ReentrantLock fairLock = new ReentrantLock(true); // 公平锁

公平锁确保先请求锁的线程先获得锁，但相对性能较低。

3. ReadWriteLock

ReadWriteLock 是一种更细粒度的锁，它允许多个读线程同时访问共享资源，但在有写操作时，写线程会独占资源。典型的实现是 ReentrantReadWriteLock。

示例代码

java">import java.util.concurrent.locks.ReentrantReadWriteLock;public class ReadWriteLockExample {private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();public void read() {rwLock.readLock().lock();try {System.out.println("Thread " + Thread.currentThread().getName() + " is reading.");} finally {rwLock.readLock().unlock();}}public void write() {rwLock.writeLock().lock();try {System.out.println("Thread " + Thread.currentThread().getName() + " is writing.");} finally {rwLock.writeLock().unlock();}}
}

这种锁的优势在于读操作不互斥，当多个线程只读数据时，能够提高系统的吞吐量。但在写操作时，所有的读操作会被阻塞，确保数据的一致性。

4. 锁优化技术

4.1 偏向锁

偏向锁 是Java的轻量级锁优化策略。它假定大多数情况下锁不会被多个线程竞争，因此，第一次获取锁时，锁会偏向获取锁的线程。如果没有其他线程竞争，这个线程之后获取锁的代价几乎为零。

偏向锁适用于线程独占资源的场景，而不适用于高并发的竞争场景。

4.2 自旋锁

自旋锁 是通过让线程循环等待一段时间，而不立即进入阻塞状态，来减少上下文切换的开销。在高并发的环境中，如果线程持有锁的时间非常短，自旋锁可以提高性能。

Java在ReentrantLock的实现中结合了自旋锁的概念，当锁的竞争不激烈时，避免线程进入阻塞状态。

4.3 Lock Support

Java还提供了 LockSupport 类，用于线程的挂起和唤醒。这是实现高级并发工具（如CountDownLatch、CyclicBarrier等）的基础。

5. 总结

synchronized：简单易用，适合基本的锁定需求，但灵活性较差。
ReentrantLock：提供更丰富的功能，如可重入、锁超时、公平锁等，适用于复杂的并发场景。
ReadWriteLock：读写分离，提高读多写少场景下的并发性能。
锁优化：如偏向锁、自旋锁、Lock Support等技术提高了锁的性能，适用于特定场景。

Java的锁机制虽然功能强大，但在实际开发中，我们需要根据具体场景选择合适的锁，并合理使用，以避免锁的滥用带来的性能问题。