ReentrantLock基础知识

最新推荐文章于 2024-09-20 09:50:19 发布
最新推荐文章于 2024-09-20 09:50:19 发布
阅读量8.5k 收藏 111
点赞数 22
分类专栏： Java多线程 文章标签： 多线程 java 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JAYU_37/article/details/113842111
版权

翻译成中文，ReentrantLock表示可重入锁，与synchronized一样，都是属于可重入锁。
与synchronized相比具有如下特点：

  • 可中断：synchronized只能等待同步代码块执行结束，不可以中断，而reentrantlock可以调用线程的interrupt方法来中断等待，继续执行下面的代码。
  • 可以设置超时时间：调用lock.trylock()，如果没有设置等待时间的话，没获取到锁，将返回false
  • 可以设置为公平锁：公平锁其实是为了解决饥饿问题，当一个线程由于优先级太低的时候，就可能没有办法获取到时间片
  • 可以支持多个变量：类似于调用wait方法时，不满足条件的线程进入waitset队列等待CPU随机调度，支持多个变量表示支持多个类似自定义waitset，这样就可以指定对象来唤醒了。

基本语法：

//获取锁
reentrantLock.lock();

try{
	//临界区
}finally{
	//释放锁
	reentrantLock.unlock();
}

1. ReentrantLock可重入

同一个线程 如果首次获取到该锁资源，则它就有权力再次获取到该锁，这就是锁的重入！

public class LockInterruptibly {

    private static ReentrantLock reentrantLock = new ReentrantLock();
    public static void main(String[] args) {
        m1();
    }

    public static void m1(){
        reentrantLock.lock();
        try {
            log.debug("m1 lock");
            m2();
        }finally {
            reentrantLock.unlock();
        }

    }
    public static void m2(){
        reentrantLock.lock();
        try {
            log.debug("m2 lock");
            m3();
        }finally {
            reentrantLock.unlock();
        }
    }

    public static void m3(){
        reentrantLock.lock();
        try {
            log.debug("m3 lock");
        }finally {
            reentrantLock.unlock();
        }
    }
}

输出：
在这里插入图片描述

2. ReentrantLock可中断

可中断指的是在尝试获取锁的过程中，可以中断该过程，并且执行相关业务。

public class LockInterruptibly {

    static ReentrantLock reentrantLock = new ReentrantLock();
    public static void main(String[] args) {

        Thread t1 = new Thread(() -> {
            try {
                log.debug("t1尝试获取锁");
                reentrantLock.lockInterruptibly();
            } catch (InterruptedException e) {
                log.debug("获取锁过程被打断");
                return;
            }

            try {
                log.debug("t1 获取到锁");
            }finally {
                reentrantLock.unlock();
            }

        }, "t1");

        //优先t1上锁
        reentrantLock.lock();
        log.debug("main获取到锁");
        t1.start();

        try {
            Thread.sleep(1000);
            t1.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            reentrantLock.unlock();
        }
    }

}

输出：
在这里插入图片描述

可见在获取锁的过中被打断后，程序return停止

注意我们这边使用的是可中断上锁lockInterruptibly，如果使用了普通的lock()

public class LockInterruptibly {

    static ReentrantLock reentrantLock = new ReentrantLock();
    public static void main(String[] args) {

        Thread t1 = new Thread(() -> {
//            try {
                log.debug("t1尝试获取锁");
                reentrantLock.lock();
//            } catch (InterruptedException e) {
//                log.debug("获取锁过程被打断");
//                return;
//            }

            try {
                log.debug("t1 获取到锁");
            }finally {
                reentrantLock.unlock();
            }

        }, "t1");

        //优先t1上锁
        reentrantLock.lock();
        log.debug("main 获取到锁");
        t1.start();

        try {
            Thread.sleep(1000);
            t1.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            reentrantLock.unlock();
        }
    }

}

程序阻塞，输出：
在这里插入图片描述

3. ReentrantLock超时时间

如果没有指定时间，则立即失败（没有获取到锁）

public class LockInterruptibly {

    static ReentrantLock reentrantLock = new ReentrantLock();
    public static void main(String[] args) {

        Thread t1 = new Thread(() -> {
            log.debug("t1尝试获取锁");
            if(!reentrantLock.tryLock()){
                log.debug("没有获取到锁");
                return;
            }

            try {
                log.debug("t1 获取到锁");
            }finally {
                reentrantLock.unlock();
            }

        }, "t1");

        //主线程上锁
        reentrantLock.lock();
        log.debug("main 获取到锁");
        t1.start();

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            reentrantLock.unlock();
        }
    }

}

输出：
在这里插入图片描述
在主线程还没释放到锁，t1线程是无法获取到锁的，因此reentrantLock.tryLock()返回false，执行没有锁的相关业务。

如果有指定时间，在指定最大时间内没有获取到锁则失败

@Slf4j(topic = "c.LockInterruptibly")
public class LockInterruptibly {

    static ReentrantLock reentrantLock = new ReentrantLock();
    public static void main(String[] args) {

        Thread t1 = new Thread(() -> {
            log.debug("t1尝试获取锁");
            try {
                if(!reentrantLock.tryLock(2,TimeUnit.SECONDS)){
                    log.debug("没有获取到锁");
                    return;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            try {
                log.debug("t1 获取到锁");
            }finally {
                reentrantLock.unlock();
            }

        }, "t1");

        //主线程上锁
        reentrantLock.lock();
        log.debug("main 获取到锁");
        t1.start();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            reentrantLock.unlock();
        }
    }

}

当等待获取锁的时间大于主线程释放锁的时间，则肯定可以获取到锁！！

用所学的tryLock知识，解决一个死锁问题：哲学家就餐问题

在这里插入图片描述

有五位哲学家，围坐在圆桌旁。
他们只做两件事，思考和吃饭，思考一会吃口饭，吃完饭后接着思考。
吃饭时要用两根筷子吃，桌上共有 5 根筷子，每位哲学家左右手边各有一根筷子。
如果筷子被身边的人拿着，自己就得等待

public class TestDeadLock {
    public static void main(String[] args) {
        Chopstick c1 = new Chopstick("1");
        Chopstick c2 = new Chopstick("2");
        Chopstick c3 = new Chopstick("3");
        Chopstick c4 = new Chopstick("4");
        Chopstick c5 = new Chopstick("5");
        new Philosopher("苏格拉底", c1, c2).start();
        new Philosopher("柏拉图", c2, c3).start();
        new Philosopher("亚里士多德", c3, c4).start();
        new Philosopher("赫拉克利特", c4, c5).start();
        new Philosopher("阿基米德", c5, c1).start();
    }
}

@Slf4j(topic = "c.Philosopher")
class Philosopher extends Thread {
    Chopstick left;
    Chopstick right;

    public Philosopher(String name, Chopstick left, Chopstick right) {
        super(name);
        this.left = left;
        this.right = right;
    }

    @Override
    public void run() {
        while (true) {
            //　尝试获得左手筷子
            synchronized (left) {
                // 尝试获得右手筷子
                synchronized (right) {
                    eat();
                }
            }
        }
    }

    Random random = new Random();
    private void eat() {
        log.debug("eating...");
        Sleeper.sleep(0.5);
    }
}

class Chopstick {
    String name;

    public Chopstick(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "筷子{" + name + '}';
    }
}

程序运行后一会儿会卡住。

使用我们之前的synchronized，就会出现死锁，即每个人某一时刻都只拥有一只筷子，又想要另外一只，此刻都无法得到另外一只，彼此都又不放开自己拥有的筷子，这种现象就是死锁。

使用ReentrantLock解决死锁问题

@Slf4j(topic = "c.Philosopher")
class Philosopher extends Thread {
    Chopstick left;
    Chopstick right;

    private ReentrantLock reentrantLock = new ReentrantLock();

    public Philosopher(String name, Chopstick left, Chopstick right) {
        super(name);
        this.left = left;
        this.right = right;
    }

    @Override
    public void run() {
        while (true) {
            if(left.tryLock()){
                try {
                    if(right.tryLock()){
                        try {
                            eat();
                        }finally {
                            right.unlock();
                        }

                    }
                }finally {
                    left.unlock();
                }
            }


        }
    }

    Random random = new Random();
    private void eat() {
        log.debug("eating...");
        Sleeper.sleep(0.5);
    }
}

class Chopstick extends ReentrantLock {
    String name;

    public Chopstick(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "筷子{" + name + '}';
    }

注意

            //while循环中的一种错误写法
            if(left.tryLock()){
                if(right.tryLock()){
                    try {
                        eat();
                    }finally {
                        left.unlock();
                        right.unlock();
                    }
                }

            }

这种错误的写法会造成一些哲学家一直哪些一些筷子不放，也就是锁没有释放，又一直加锁，会导致上锁的次数超过预期的
在这里插入图片描述

4. ReentrantLock支持多个变量

支持多个变量类似于synchronized的waitset休息室，当条件不满足时，进入waitset队列等待，ReentrantLock的强大之处在于支持多个自定义的waitset，这样就可以灵活的应对和唤醒指定的线程。

使用要点：

  • await前需要获取到锁
  • await执行后会释放锁，进入conditionObject等待
  • await线程被唤醒（超时或打断后）重新竞争ReentrantLock锁
  • 竞争到ReentrantLock后，继续执行await后的代码

看一个例子：

public class TestWaitNotify {
    final static Object room = new Object();
    static boolean hasCigarette = false;
    static boolean hasTakeout = false;


    public static void main(String[] args) {

        //小南
        new Thread(() -> {
            synchronized (room) {
                log.debug("有烟没？[{}]", hasCigarette);
                if (!hasCigarette) {
                    log.debug("没烟，先歇会！");
                    try {
                        room.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("有烟没？[{}]", hasCigarette);
                if (hasCigarette) {
                    log.debug("可以开始干活了");
                }
            }
        }, "小南").start();

        //小女等外卖
        new Thread(() -> {
            synchronized (room) {
                Thread thread = Thread.currentThread();
                log.debug("外卖送到没？[{}]", hasTakeout);
                if (!hasTakeout) {
                    log.debug("没外卖，先歇会！");
                    try {
                        room.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("外卖送到没？[{}]", hasTakeout);
                if (hasTakeout) {
                    log.debug("可以开始干活了");
                } else {
                    log.debug("没干成活...");
                }
            }
        }, "小女").start();

        //送外卖
        sleep(1);
        new Thread(() -> {
            synchronized (room) {
                hasTakeout = true;
                log.debug("外卖到了噢！");
                room.notify();
            }
        }, "送外卖的").start();
    }
}

输出：
在这里插入图片描述
synchronized 的弊端也很明显了，只能有一个休息室，所以唤醒的目标无法明确。

使用ReentrantLock 改进

public class Test17 {

    private static ReentrantLock lock = new ReentrantLock();
    //等烟休息室
    static Condition cigaretteRoom = lock.newCondition();
    //等外卖休息室
    static Condition eattingRoom = lock.newCondition();

    static boolean hasCigarette = false;
    static boolean hasTakeout = false;


    public static void main(String[] args) throws InterruptedException {

        //小南
        new Thread(() -> {
            lock.lock();
            try {
                log.debug("有烟没？[{}]", hasCigarette);
                while (!hasCigarette) {
                    log.debug("没烟，先歇会！");
                    try {
                        cigaretteRoom.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("有烟没？[{}]", hasCigarette);
                if (hasCigarette) {
                    log.debug("可以开始干活了");
                }
            }finally {
                lock.unlock();
            }

        }, "小南").start();

        //小女等外卖
        new Thread(() -> {
            lock.lock();
            try {
                Thread thread = Thread.currentThread();
                log.debug("外卖送到没？[{}]", hasTakeout);
                while (!hasTakeout) {
                    log.debug("没外卖，先歇会！");
                    try {
                        eattingRoom.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("外卖送到没？[{}]", hasTakeout);
                if (hasTakeout) {
                    log.debug("可以开始干活了");
                } else {
                    log.debug("没干成活...");
                }
            }finally {
                lock.unlock();
            }
        }, "小女").start();

        //送烟的来了
        Thread.sleep(1000);
        new Thread(() -> {
            lock.lock();
            try {
                hasCigarette = true;
                cigaretteRoom.signal();
            }finally {
                lock.unlock();
            }

        }, "送烟的").start();

        //送外卖的来了
        Thread.sleep(1000);
        new Thread(() -> {
            lock.lock();
            try {
                hasTakeout = true;
                eattingRoom.signal();
            }finally {
                lock.unlock();
            }


        }, "送外卖的").start();
    }
}

输出：
在这里插入图片描述
需要注意的是

Thread.sleep(1000);
        new Thread(() -> {
            lock.lock();
            try {
                hasCigarette = true;
                cigaretteRoom.signal();
            }finally {
                lock.unlock();
            }

        }, "送烟的").start();

其中

hasCigarette = true;
cigaretteRoom.signal();

必须在获取锁之后才能执行，同时也要注意unlock，这也是相比于synchronized 较为繁琐的。

多个线程的lock会出现堵塞，但是await会暂时让出锁资源，所以可以开断电调试便以观察程序的具体运行过程。

5. ReentrantLock公平性

多线程情况下部分线程无法获取到CPU的时间片，导致线程饥饿问题，ReentrantLock默认是不开启公平规则的，公平性就是为了解决该问题而产生的。

启动公平性

ReentrantLock unFair = new ReentrantLock(true);

看一个例子：

@Slf4j(topic = "c.TestFair")
public class TestFair implements Runnable {

    private  ReentrantLock reentrantLock;  //锁
    private static Integer num = 0;

    public TestFair(ReentrantLock reentrantLock){
        this.reentrantLock = reentrantLock;
    }

    @Override
    public void run() {
        while (true){
            reentrantLock.lock();
            try {
                num ++;
                log.debug(Thread.currentThread().getName() + num);
            }finally {
                reentrantLock.unlock();
            }

        }
    }

    public static void main(String[] args) {

        //公平锁
        ReentrantLock fair = new ReentrantLock(true);
        new Thread(new TestFair(fair),"t1").start();
        new Thread(new TestFair(fair),"t2").start();

        //不公平锁
//        ReentrantLock unFair = new ReentrantLock(false);
//        new Thread(new TestFair(unFair),"t1").start();
//        new Thread(new TestFair(unFair),"t2").start();
    }
}

公平性下的输出：
在这里插入图片描述
线程之间都交替运行。

不公平下的输出：
在这里插入图片描述
可见，这就是饥饿问题。

学习资料:
https://www.bilibili.com/video/BV16J411h7Rd?p=127

Java 并发编程：ReentrantLock 锁与 AQS
栗筝i的博客
08-10 1394
大家好，我是栗筝i，这篇文章是我的 “栗筝i 的 Java 技术栈” 专栏的第 030 篇文章，在 “栗筝i 的 Java 技术栈” 这个专栏中我会持续为大家更新 Java 技术相关全套技术栈内容。专栏的主要目标是已经有一定 Java 开发经验，并希望进一步完善自己对整个 Java 技术体系来充实自己的技术栈的同学。与此同时，本专栏的所有文章，也都会准备充足的代码示例和完善的知识点梳理，因此也十分适合零基础的小白和要准备工作面试的同学学习。
22. Java ReentrantLock 使用
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-08 983
本节内容主要是对 ReentrantLock 的使用进行讲解，之前对于 Lock 接口进行了讲解，ReentrantLock 是 Lock 接口的常用实现子类，占据着十分重要的地位。ReentrantLock 基本方法的使用，即 lock 与 unlock 方法的使用，这是最基础的方法使用，为重点内容；ReentrantLock lockInterruptibly 与 tryLock 方法的使用，也是经常使用到的方法，为本节重点内容；
ReentrantLock
m0_58186166的博客
10-25 273
1、标题、分类 2、正文 附带源码，版本1.8 零、开头介绍（红涛） 一、简短的对比Synchronized，增加使用场景（吴磊） 二、示例代码，贴合场景（盼盼） 三、源码解读 Lock、ReentrantLock API源码（晓萱） AQS（红涛） CAS思想、问题、在哪用（进福） 四、最终总结：短小精湛的总结（盼盼） ...
ReentrantLock原理及详细的使用方法
最新发布
yymagicer的博客
09-20 661
的核心是基于AQS（抽象队列同步器）实现的。AQS 维护了一个队列，用于管理所有请求锁的线程。每个线程尝试获取锁时，如果当前锁被其他线程持有，则进入等待队列，阻塞等待锁释放。一旦锁释放，AQS 会从队列中唤醒下一个线程，允许它获取锁。提供了比更灵活的锁控制方式。选择公平锁和非公平锁；提供尝试获取锁和可中断的锁；允许锁的重入；支持手动加锁和解锁的细粒度控制。
ReentrantLock 锁详解
m0_37235955的博客
04-27 3485
ReentrantLock 支持公平锁和非公平锁，可重入锁 ReentrantLock的底层是通过 **AQS[链接]**实现。 一、BAT 大厂的面试题 **【1】**什么是可重入，什么是可重入锁? 它用来解决什么问题? 【2】ReentrantLock 的核心是 AQS，那么它怎么来实现的，继承吗? 说说其类内部结构关系。 【3】ReentrantLock 是如何实现公平锁的? 【4】ReentrantLock 是如何实现非公平锁的? 【5】ReentrantLock 默认实现的是公平还是非公平锁.
ReentrantLock实现原理详解
08-31
- **基础知识**：ReentrantLock的lock()和unlock()方法依赖于AQS的同步机制。可重入性和可中断性是其关键特性。 - **NonfairSync**：ReentrantLock默认实现是非公平的，即lock()方法可能不按线程到达的顺序分配锁...
Java基础知识点汇总
09-25
### Java基础知识点汇总 #### 一、JAVA反射机制的作用及应用 **作用：** 1. **动态获取类信息：** 反射可以让程序在运行时动态地获取类的信息，包括类名、方法名、字段等。 2. **动态创建实例：** 可以通过反射...
java面试，Java基础知识
07-05
### Java基础知识 #### 1. Java核心特性 - **面向对象编程**：Java是一种完全的面向对象编程语言，这意味着所有代码都是围绕“对象”来构建的。对象是类的实例，具有状态（属性）和行为（方法）。面向对象编程的...
ReentrantLock详解
热门推荐
weixin_56738054的博客
01-09 1万+
ReentrantLock使用，
ReentrantLock锁
weixin_46121031的博客
05-14 7195
1. 简介 ReentrantLock，可重入锁，是一种递归无阻塞的同步机制。它可以等同于 synchronized 的使用，但是 ReentrantLock 提供了比 synchronized 更强大、灵活的锁机制，可以减少死锁发生的概率
浅谈ReentrantLock
裸奔的小强的博客
04-19 292
ReentrantLock 构造方法: //默认使用的是非公平的锁 public ReentrantLock() { sync = new NonfairSync(); } public ReentrantLock(boolean fair) { sync = fair ? new FairSync() : new NonfairS...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值