Java的锁机制详解
在并发编程中，锁 是用于控制多个线程对共享资源进行访问的工具。Java提供了多种锁机制，从最基础的 synchronized 到高级的 ReentrantLock，这些锁帮助我们确保线程安全，并能有效避免数据竞争和死锁问题。
1. synchronized 关键字
synchronized 是Java中最简单的锁机制。它可以锁住方法或者代码块，确保某个线程在访问共享资源时，其他线程无法访问同一个资源。
示例代码：同步方法
public class SynchronizedExample {
public synchronized void synchronizedMethod() {
System.out.println("Thread " + Thread.currentThread().getName() + " is executing synchronized method.");
}
}
在上述代码中，synchronizedMethod 方法被 synchronized 关键字修饰，意味着同一时间只能有一个线程执行该方法。
示例代码：同步代码块
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 基本使用
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 是非公平锁，即等待时间长的线程不一定优先获得锁。你可以通过构造函数指定是否为公平锁：
ReentrantLock fairLock = new ReentrantLock(true); // 公平锁
公平锁确保先请求锁的线程先获得锁，但相对性能较低。
3. ReadWriteLock
ReadWriteLock 是一种更细粒度的锁，它允许多个读线程同时访问共享资源，但在有写操作时，写线程会独占资源。典型的实现是 ReentrantReadWriteLock。
示例代码
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的锁机制虽然功能强大，但在实际开发中，我们需要根据具体场景选择合适的锁，并合理使用，以避免锁的滥用带来的性能问题。
原文地址：https://blog.csdn.net/problc/article/details/142769744
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！