Java Lock 锁如何实现锁细化

Java Lock 提供了比 synchronized 更灵活的锁机制，可以实现锁细化。锁细化是指在不同的代码段上使用不同类型的锁，以提高并发性能和减少线程竞争。以下是如何在 Java 中使用 Lock 实现锁细化的示例：

1. 使用 ReentrantLock：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockExample {
    private final Lock lock = new ReentrantLock();

    public void method1() {
        lock.lock();
        try {
            // 访问共享资源
        } finally {
            lock.unlock();
        }
    }

    public void method2() {
        lock.lock();
        try {
            // 访问另一个共享资源
        } finally {
            lock.unlock();
        }
    }
}

在这个例子中，我们使用了 ReentrantLock 对象 lock，并在不同的方法 method1() 和 method2() 上分别加锁。这样可以确保在同一时间只有一个线程可以访问这些方法中的共享资源。

2. 使用 ReadWriteLock：

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockExample {
    private final ReadWriteLock lock = new ReentrantReadWriteLock();

    public void writeData() {
        lock.writeLock().lock();
        try {
            // 写入共享资源
        } finally {
            lock.writeLock().unlock();
        }
    }

    public void readData() {
        lock.readLock().lock();
        try {
            // 读取共享资源
        } finally {
            lock.readLock().unlock();
        }
    }
}

在这个例子中，我们使用了 ReadWriteLock 对象 lock，它允许多个线程同时读取共享资源，但在写入时会阻塞其他线程的读取和写入操作。这样可以在读操作远多于写操作的情况下提高并发性能。

通过在不同的代码段上使用不同类型的锁，我们可以实现锁细化，从而提高程序的性能和可扩展性。