java 可重入锁如何实现

Java 可重入锁通过线程独占、递归获取锁、基于公平性策略等机制实现。

线程独占：在Java中，可重入锁（ReentrantLock）允许线程在拥有锁的情况下再次获得锁而不会被阻塞。这与synchronized关键字的内置锁行为一致，当一个线程已经拥有了锁，它可以在同一个锁对象上再次获得锁而不会被阻塞。

递归获取锁：ReentrantLock的实现允许同一个线程多次获取同一个锁。这是通过一个计数器来实现的，每次获取锁时计数器增加1，每次释放锁时计数器减少1。当计数器为0时，锁被完全释放。

基于公平性策略：ReentrantLock提供了公平锁和非公平锁的选择。公平锁确保线程获取锁的顺序是按照线程请求锁的顺序，而非公平锁则没有这种保证，可能会更高效但可能导致线程饥饿。

接下来，我们详细讨论这些方面并探讨Java可重入锁的具体实现。

一、线程独占

Java中的ReentrantLock实现了Lock接口，它提供了一种与synchronized关键字类似的机制来实现线程独占。ReentrantLock的主要特点是它允许一个线程多次获取同一个锁，而不会引起死锁。以下是一些关键点：

1. 独占模式

ReentrantLock是一种独占锁，这意味着一次只有一个线程可以持有锁。其他试图获取锁的线程会被阻塞，直到持有锁的线程释放锁。

2. 状态管理

ReentrantLock使用一个内部的状态变量来跟踪锁的状态。当一个线程获取锁时，状态变量增加；当线程释放锁时，状态变量减少。当状态变量为0时，锁被完全释放。

public class ReentrantLockDemo {
    private final ReentrantLock lock = new ReentrantLock();
    public void performTask() {
        lock.lock();  // 获取锁
        try {
            // 执行任务
        } finally {
            lock.unlock();  // 释放锁
        }
    }
}

在上述代码中，lock.lock()用于获取锁，如果当前锁已经被其他线程持有，当前线程将被阻塞直到锁被释放。lock.unlock()用于释放锁。

二、递归获取锁

ReentrantLock允许同一个线程多次获取同一个锁，这是通过一个计数器来实现的。每次一个线程获取锁时，计数器增加1；每次线程释放锁时，计数器减少1。当计数器为0时，锁被完全释放。

1. 递归锁的优势

递归锁允许在一个线程中多次进入临界区。这对于一些需要在同一个线程中多次调用的方法尤其重要。例如，递归调用或者在一个锁的持有过程中调用其他方法，这些方法也需要获取同一个锁。

public class ReentrantLockDemo {
    private final ReentrantLock lock = new ReentrantLock();
    public void outerMethod() {
        lock.lock();
        try {
            innerMethod();
        } finally {
            lock.unlock();
        }
    }
    public void innerMethod() {
        lock.lock();
        try {
            // 业务逻辑
        } finally {
            lock.unlock();
        }
    }
}

在上述代码中，outerMethod和innerMethod都获取了同一个锁对象。这是通过递归锁的特性实现的。

三、基于公平性策略

ReentrantLock提供了公平锁和非公平锁的选择。公平锁确保线程获取锁的顺序是按照线程请求锁的顺序，而非公平锁则没有这种保证。

1. 公平锁

公平锁通过一个队列来管理请求锁的线程。每当一个线程释放锁时，队列中的第一个线程将被唤醒并获取锁。这确保了线程获取锁的顺序是按照请求的顺序。

ReentrantLock fairLock = new ReentrantLock(true);

在上述代码中，new ReentrantLock(true)创建了一个公平锁。

2. 非公平锁

非公平锁没有严格的顺序保证，当一个线程释放锁时，任何一个等待的线程都有机会获取锁。非公平锁可能会更高效，因为它减少了线程切换的开销。

ReentrantLock unfairLock = new ReentrantLock(false);

在上述代码中，new ReentrantLock(false)创建了一个非公平锁。

四、ReentrantLock的实现细节

为了深入理解Java可重入锁的实现，我们需要探讨ReentrantLock的内部工作原理。以下是一些关键点：

1. 内部类Sync

ReentrantLock使用一个内部类Sync来管理锁的状态。Sync继承自AbstractQueuedSynchronizer（AQS），这是一个提供了线程同步原语的框架。

abstract static class Sync extends AbstractQueuedSynchronizer {
    abstract void lock();
}

Sync有两个子类：FairSync和NonfairSync，分别实现了公平锁和非公平锁的逻辑。

2. 获取锁

获取锁的逻辑在Sync类中实现。对于非公平锁，获取锁的方法如下：

final void lock() {
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);
}

对于公平锁，获取锁的方法如下：

final void lock() {
    acquire(1);
}

在这两种情况下，acquire方法是从AQS继承的，它会将当前线程加入等待队列，并尝试获取锁。

3. 释放锁

释放锁的逻辑也在Sync类中实现：

protected final boolean tryRelease(int releases) {
    int c = getState() - releases;
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }
    setState(c);
    return free;
}

这段代码会减少锁的计数器，如果计数器为0，锁将被完全释放。

五、ReentrantLock的使用场景

ReentrantLock在许多场景中都有广泛的应用，以下是一些常见的使用场景：

1. 需要灵活的锁定策略

ReentrantLock提供了更灵活的锁定策略，例如公平锁和非公平锁的选择。这对于需要严格控制线程获取锁的顺序的场景非常有用。

2. 需要尝试锁定

ReentrantLock提供了tryLock方法，允许线程尝试获取锁，如果锁不可用，线程可以选择不阻塞并继续执行其他任务。

if (lock.tryLock()) {
    try {
        // 获取到锁，执行任务
    } finally {
        lock.unlock();
    }
} else {
    // 未获取到锁，执行其他任务
}

3. 需要可中断的锁定

ReentrantLock提供了lockInterruptibly方法，允许线程在等待获取锁时被中断。这对于需要响应中断的场景非常有用。

try {
    lock.lockInterruptibly();
    try {
        // 执行任务
    } finally {
        lock.unlock();
    }
} catch (InterruptedException e) {
    // 处理中断
}

六、ReentrantLock的最佳实践

为了充分利用ReentrantLock的功能并避免常见的陷阱，以下是一些最佳实践：

1. 始终在finally块中释放锁

确保在获取锁后始终在finally块中释放锁，以避免死锁。

lock.lock();
try {
    // 执行任务
} finally {
    lock.unlock();
}

2. 根据需求选择公平锁或非公平锁

根据具体需求选择公平锁或非公平锁。公平锁适用于需要严格控制线程获取锁的顺序的场景，而非公平锁可能在性能上更高效。

3. 避免长时间持有锁

避免长时间持有锁，以减少其他线程的等待时间。这可以通过将锁定范围尽量缩小来实现。

lock.lock();
try {
    // 尽量减少锁定范围
} finally {
    lock.unlock();
}

4. 使用tryLock避免死锁

在一些情况下，使用tryLock可以避免死锁。tryLock允许线程尝试获取锁，如果锁不可用，线程可以选择不阻塞并继续执行其他任务。

if (lock.tryLock()) {
    try {
        // 获取到锁，执行任务
    } finally {
        lock.unlock();
    }
} else {
    // 未获取到锁，执行其他任务
}

5. 避免嵌套锁定

嵌套锁定容易导致死锁，尽量避免在一个锁的持有过程中获取另一个锁。

七、ReentrantLock与synchronized的对比

ReentrantLock和synchronized都是Java中用于实现线程同步的机制，它们各有优劣：

1. 灵活性

ReentrantLock提供了更多的灵活性，例如尝试锁定、可中断锁定以及公平锁和非公平锁的选择。而synchronized关键字则比较简单易用。

2. 性能

在高竞争的情况下，ReentrantLock可能比synchronized关键字更高效，因为它减少了线程切换的开销。然而，在低竞争的情况下，synchronized关键字的性能可能更好，因为它由JVM内部优化。

3. 可重入性

两者都支持可重入性，允许同一个线程多次获取同一个锁。

4. 可见性

synchronized关键字内置了内存屏障，确保了变量的可见性。而ReentrantLock需要手动确保可见性，通常通过volatile变量或其他同步机制来实现。

八、总结

Java可重入锁通过线程独占、递归获取锁以及基于公平性策略等机制实现。ReentrantLock提供了更灵活的锁定策略，例如公平锁和非公平锁的选择，并支持尝试锁定和可中断锁定。ReentrantLock的实现依赖于AbstractQueuedSynchronizer（AQS）框架，通过内部类Sync管理锁的状态。ReentrantLock在需要灵活锁定策略、尝试锁定或可中断锁定的场景中非常有用。为了充分利用ReentrantLock的功能并避免常见的陷阱，建议遵循最佳实践，如始终在finally块中释放锁、根据需求选择公平锁或非公平锁、避免长时间持有锁、使用tryLock避免死锁以及避免嵌套锁定。ReentrantLock和synchronized关键字各有优劣，选择哪种机制取决于具体的应用场景和需求。