ReentrantLock相较于synchronized有哪些区别（一）？

最新推荐文章于 2025-04-01 13:24:07 发布

ADRU

最新推荐文章于 2025-04-01 13:24:07 发布

阅读量355

点赞数 9

分类专栏： juc 文章标签： java 开发语言

本文链接：https://blog.youkuaiyun.com/m0_71507863/article/details/136025074

版权

juc 专栏收录该内容

7 篇文章

订阅专栏

本文详细介绍了JavaReentrantLock的特点，包括可中断、设置超时时间、公平锁机制以及可重入性，并通过示例展示了如何在实际场景中使用这些特性。

摘要由优快云通过智能技术生成

ReentrantLock特点

相对于 synchronized 它具备如下特点

可中断

可以设置超时时间

可以设置为公平锁

支持多个条件变量

与 synchronized 一样，都支持可重入

基本使用语法如下：

public class Test {
    public static void main(String[] args) {
        ReentrantLock reentrantLock = new ReentrantLock();
        reentrantLock.lock();
        try{
            // 业务代码逻辑
        }finally {
            reentrantLock.unlock();
        }

    }
}

可重入

可重入是指同一个线程如果首次获得了这把锁，那么因为它是这把锁的拥有者，因此有权利再次获取这把锁。如果是不可重入锁，那么第二次获得锁时，自己也会被锁挡住


import java.util.concurrent.locks.ReentrantLock;

public class Test {
    static ReentrantLock lock = new ReentrantLock();
    public static void main(String[] args) {
        m1();
    }
    public static void m1(){
        lock.lock();
        try{
            System.out.println("m1 加锁成功");
            m2();
        }finally {
            lock.unlock();
        }
    }
    public static void m2(){
        lock.lock();
        try{
            System.out.println("m2 加锁成功");
            m3();
        }finally {
            lock.unlock();
        }
    }
    public static void m3(){
        lock.lock();
        try{
            System.out.println("m2 加锁成功");
        }finally {
            lock.unlock();
        }
    }
}

运行结果：可以发现全部加锁成功了

可打断

调用lockInterruptibly()方法执行打断

import java.util.concurrent.locks.ReentrantLock;

import static java.lang.Thread.sleep;

public class Test {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        Thread t1 = new Thread(() -> {
            System.out.println("线程1开始执行");
            try {
                lock.lockInterruptibly();
            } catch (Exception e) {
                System.out.println("线程1锁被打断");
                e.printStackTrace();
                return;
            }
            try {
                System.out.println("线程1加锁成功");
            } finally {
                lock.unlock();
            }
        }, "t1");

        lock.lock();
        System.out.println("主线程获得了锁");
        t1.start();
        try{
            sleep(1);
            t1.interrupt();
            System.out.println("执行打断");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

注意如果是不可中断模式，那么即使使用了 interrupt 也不会让等待中断

例子：


import java.util.concurrent.locks.ReentrantLock;

import static java.lang.Thread.sleep;

public class Test {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        Thread t1 = new Thread(() -> {
            System.out.println("线程1开始执行");
            try {
                lock.lock();
            } catch (Exception e) {
                System.out.println("线程1锁被打断");
                e.printStackTrace();
                return;
            }
            try {
                System.out.println("线程1加锁成功");
            } finally {
                lock.unlock();
            }
        }, "t1");

        lock.lock();
        System.out.println("主线程获得了锁");
        t1.start();
        try{
            sleep(1);
            t1.interrupt();
            System.out.println("执行打断");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

执行结果：