并发学习（三）ReentrantLock可重入锁

最新推荐文章于 2024-12-25 12:45:00 发布

云哥Y

最新推荐文章于 2024-12-25 12:45:00 发布

阅读量172

点赞数

分类专栏：并发编程

本文链接：https://blog.youkuaiyun.com/fu123123fu/article/details/103587894

版权

并发编程专栏收录该内容

12 篇文章

订阅专栏

本文深入解析可重入锁（ReentrantLock）的工作原理，通过实例展示其如何避免死锁，确保线程安全。并对比synchronized关键字，演示ReentrantLock实现原子性的具体案例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

前面提到了Lock，但它只是一个接口，真正的实现代表类是ReentrantLock。

什么是ReentrantLock

字面意思就很容易理解：可重入锁。例如有一个线程A调用了lock方法获得锁后，再次调用lock，也能直接获得锁而不需要去阻塞，只需要增加重入次数即可。synchronized和ReentrantLock都是属于可重入锁，下面来看一个经典案例。

public class ReentrantTest {

    public static void main(String[] args) {
        final ReentrantTest test = new ReentrantTest();
        new Thread(new Runnable() {
            @Override
            public void run() {
                test.funA();
            }
        }).start();
    }

    public synchronized void funA() {
        System.out.println("开始执行A方法...");
        funB();
    }

    public void funB() {
        System.out.println("开始执行B方法...");
        synchronized (this) {
            System.out.printf("执行成功。");
        }
    }

}

解析： main方法里启一个线程，然后调用同步方法funA，funA内部又调用了同步方法funB。因为可重入锁的缘故，线程在funA获得了锁，funB也能直接获得锁，程序执行正常。
假设没有重入锁： 再次解析以上代码，首先还是main方法里启一个线程，然后调用同步方法funA，funA内部又调用了同步方法funB，funB同步代码块里需要获得锁，但是funA没有执行完funB不会释放锁，而funB不能获得锁只能继续等待着，这样就形成：funA永远没法执行完程序释放锁，funB永远等待着获得锁，于是乎，死锁了！
所以，可重入锁最关键的就是解决死锁问题。

ReentrantLock实现原子性的案例

ReentrantLock用法达到的效果跟synchronized基本一样，下面来看下它实现原子性的案例：

public class AtomicDemo {

    private static int count = 0;

    static Lock lock = new ReentrantLock();

    public static void incre() {
        lock.lock();
        try {
            Thread.sleep(1);
            count++;
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 1000; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    AtomicDemo.incre();
                }
            }).start();
        }
        // 主线程阻塞3秒，等待子线程执行完
        Thread.sleep(3000);
        System.out.println("count=" + count);
    }
}