ReentrantLock

最新推荐文章于 2023-04-30 20:49:03 发布

厚积薄发ض

最新推荐文章于 2023-04-30 20:49:03 发布

阅读量579

点赞数 1

分类专栏： Java并发编程 JavaEE 文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_61210742/article/details/128619544

版权

JavaEE 同时被 2 个专栏收录

32 篇文章 3 订阅

订阅专栏

Java并发编程

8 篇文章 0 订阅

订阅专栏

ReentrantLock解决哲学家就餐问题

ReentrantLock公平锁

ReentrantLock条件变量

ReentrantLock

ReentrantLock 相比于synchronized的特点 :

可中断:比如A线程拥有锁,B线程能给他取消掉
可以设置超时时间,规定一段时间竞争锁,如果获取不到锁,那么就不竞争了做一些其他的逻辑.
可以设置为公平锁 ,防止线程饥饿的情况,大家都在排队等,先到的先得到锁.
支持多个条件变量 ,相当于waitSet(条件不满足等待的地方),支持多个WaitSet里面等

相当于一个房子有不同的休息室,对其进行细分.

相同点 : 都是支持可重入的.同一个线程可以对同一个对象反复加锁.

ReentrantLock语法

//创建一个ReentrantLock对象
private static ReentrantLock lock =new ReentrantLock();
public static void main(String[] args) {
    //调用lock方法加锁
    lock.lock();
    try{
        //临界区的代码
    }finally {
        //必须对其进行解锁,所以放在finally块
        lock.unlock();
    }
}

ReentrantLock可重入

Synchronized和ReentrantLock都是可重入锁.

可重入锁也就是同一个线程首次获得了这把锁,也就是称为这把锁的拥有者,因此有权利再次获取这把锁,也就是同一个线程可以对同一个对象反复加锁

相反之,就有不可重入锁.

不可重入锁就是当第二次获取锁的时候,就会被锁挡住.

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.locks.ReentrantLock;

@Slf4j(topic = "c.ReentrantFeatures")
public class ReentrantFeatures {
    /**
     * ReentrantLock可重入特性演示
     * @param args
     */
    private static ReentrantLock lock = new ReentrantLock();
    public static void main(String[] args) {
        lock.lock();
        try {
            log.debug("enter main");
           m1();
        }finally {
            lock.unlock();
        }
    }
    public static void m1() {
        lock.lock();
        try {
            log.debug("enter m1");
            m2();
        }finally {
            lock.unlock();
        }
    }
    public static void m2() {
        lock.lock();
        try {
            log.debug("enter m2");
        }finally {
            lock.unlock();
        }
    }
}

如果是不可重入锁,第二次获取锁的时候就会被挡住

ReentrantLock可打断

ReentrantLock可打断支持可打断的特性,通过调用ReentrantLock对象的lockinterruptibly()方法,其他线程就可以使用interrupt()方法对其打断可以防止无限制的等待下去,避免死锁.

在有竞争的情况下,如果该lockinterruptibly()方法没有被其他线程打断,那么和lock方法一样会死等线程释放锁.知道获取到锁

@Slf4j(topic = "c.LockInterruptiblyFeatures")
public class LockInterruptiblyFeatures {
    /**
     * 演示ReentrantLock可打断的特性
     */
    private static ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            try {
                log.debug("尝试获取锁");
                lock.lockInterruptibly();
            } catch (InterruptedException e) {
                e.printStackTrace();
                log.debug("没有获取到锁,被打断,返回");
                return;
            }
            try {
                log.debug("获取到锁");
            }finally {
                lock.unlock();
            }
        });
        log.debug("获取到锁");
        lock.lock();
        t1.start();
        try{
            log.debug("1s后打断t1");
            //主线程1s后打断t1线程
            Thread.sleep(1000);
            t1.interrupt();
        }finally {
            lock.unlock();
        }
    }
}

通过调用ReentrantLock对象的lockinterruptibly()方法,其他线程就可以使用interrupt()方法对其打断可以防止无限制的等待下去,避免死锁.

ReentrantLock锁超时

可打断的这个特点是被动地避免死等,由其他线程调用interrupt方法让其不要继续死等.

锁超时是主动地避免死等,在获取锁的过程中,如果其他线程持有者锁一直没有释放,尝试获取锁的线程也不会死等,会设置一个超时时间,如果超过了这个超时时间,如果其他线程仍然没有释放锁,那么当前线程获取锁失败,避免无限制的等待下去,也就避免了死锁.

通过tryLock()方法可以实现锁超时

tryLock()方法不带参数 :-->没有设置超时时间

获取锁成功返回true,获取锁失败返回false

tryLock()方法带参数 :-->表示可以设置超时时间

获取锁成功返回true,如果超过超时的时间还没有获取到锁,就获取锁失败,返回false

@Slf4j(topic = "c.TryLock")
public class TryLock {
    /**
     * 演示ReentrantLock锁超时的情况
     */
    private static ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            try {
                if(!lock.tryLock(1, TimeUnit.SECONDS)) {
                    log.debug("没有获取到锁,立即返回");
                    return;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
                //tryLock也可以被打断,没有获取到锁
                log.debug("被打断,没有获取到锁,立即返回");
                return;
            }
            log.debug("获取到锁");
            try {
                //执行临界区代码
                log.debug("执行临界区代码");
            }finally {
                //解锁
                lock.unlock();
            }
        },"t1");
        log.debug("获取锁");
        lock.lock();
        t1.start();
        try{
            Thread.sleep(2000);
        }finally {
            log.debug("释放锁");
            lock.unlock();
        }
    }
}

没有超过超时时间获取到锁

超过超时时间没有获取到锁

ReentrantLock解决哲学家就餐问题

package com.example.demo.Controller.DiningPhilosophersProblem;

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.Philosophers")
public class Philosophers extends Thread{
    private Chopstick left;//左手筷子
    private Chopstick right;//右手筷子

    public Philosophers(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();
                }
            }
        }
    }

    private void eat() {
        log.debug("eating...");
        try {
            Thread.sleep(200);//思考1s钟
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

分析一下,为啥这样能解决死锁,对于synchronized,也就是没有获取到,就一直死等

而对于ReentrantLock来说,如果没有获取到锁就不等了,防止无限制等待.如果获取到了左手筷子,但没有获取到右手筷子,那么他也会同时释放左手筷子,让其他哲学家先吃

ReentrantLock公平锁

所谓公平锁,也就是先到先得. 如果多个线程获取锁的时候,就会去等待队列EntryList中去排队等待,如果是公平锁也就是排在前面的线程先获取到锁,排在后面的后获取到锁.

而非公平锁,并不是先到先得,而是谁竞争到了谁就先获取到锁.

ReentrantLock条件变量

对于条件变量我们可以理解为 synchronized的WaitSet,也就是条件不满足的时候就调用wait方法去WaitSet中等待,这个WaitSet就相当于条件变量.

对于ReentrantLock来说 ReentrantLock支持多个条件变量,将其条件更加细分

就相当于 :

synchronized是那些不满足线程都在一间休息室(同一个WaitSet)中等待.
对于ReentrantLock来说支持多间休息室,有专门等外卖的休息室,有专门等待烟的休息室,唤醒也是按照休息室来唤醒的.

使用要点：

await 前需要获得锁
await 执行后，会释放锁，进入 conditionObject 等待
await 的线程被唤醒（或打断、或超时）取重新竞争 lock 锁
竞争 lock 锁成功后，从 await 后继续执行

@Slf4j(topic = "c.TestDemo1")
public class TestDemo1 {
    static ReentrantLock lock = new ReentrantLock();
    public static void main(String[] args) throws InterruptedException {
        //要想进入条件变量(消息室) 必须获取到锁
        lock.lock();
        //一个锁对象可以由多个条件变量(多个休息室) 将其细分
        Condition condition1 = lock.newCondition();
        Condition condition2 = lock.newCondition();
        try{
            //去休息室1 里面等待
            condition1.await();
            
        }finally {
            lock.unlock();
        }
        //唤醒条件变量1(休息室1)的线程
        condition1.signal();
        //唤醒条件变量2(休息室2)所有的线程
        condition1.signalAll();
    }
}

Condition代码练习

import lombok.extern.slf4j.Slf4j;

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

@Slf4j(topic = "c.TestWaitNotify3")
public class TestCondition {
    private static boolean isCigarette = false;
    private static boolean isTakeOut = false;
    //每一个人不用去同一间休息室等了,而是去不同的休息室等待,这样就避免了通一间休息室全部唤醒的问题->虚假唤醒
    private static ReentrantLock ROOM = new ReentrantLock();//一个大房间有多间休息室
    private  static Condition cigaretteWaitSet = ROOM.newCondition();
    private  static Condition takeOutWaitSet = ROOM.newCondition();

    public static void main(String[] args) throws InterruptedException {
        //小南等烟
        new Thread(()->{
            ROOM.lock();
            try{
                log.debug("是否有香烟 : " +isCigarette);
                if(!isCigarette){
                    log.debug("没有香烟,干不了活,等一会");
                    try {
                        cigaretteWaitSet.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("小南开始干活");
            }finally {
                ROOM.unlock();
            }
        },"小南").start();

        //小女等外卖
        new Thread(()->{
            ROOM.lock();
            try{
                log.debug("是否有外卖 : " +isTakeOut);
                if(!isTakeOut){
                    log.debug("没有外卖,干不了活,等一会");
                    try {
                        takeOutWaitSet.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("小女干活");
            }finally {
                ROOM.unlock();
            }
        },"小女").start();

        Thread.sleep(1000);
        new Thread(()->{
            ROOM.lock();
            try {
                isTakeOut = true;
                log.debug("外卖到了");
                takeOutWaitSet.signal();
            }finally {
                ROOM.unlock();
            }
        },"送外卖的").start();
        Thread.sleep(1000);
        new Thread(()->{
            ROOM.lock();
            try {
                isCigarette = true;
                log.debug("烟到了");
                cigaretteWaitSet.signal();
            }finally {
                ROOM.unlock();
            }
        },"送烟的").start();
    }
}

对之前的代码做出改进使用ReentrantLock,这样两个人就不用去同一间休息室等待了,可以去同一个房间的不同休息室等待,这样当唤醒时候,不会把所有人都唤醒.

厚积薄发ض

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
ReentrantLock

在获取锁的过程中,如果其他线程持有者锁一直没有释放,尝试获取锁的线程也不会死等,会设置一个超时时间,如果超过了这个超时时间,如果其他线程仍然没有释放锁,那么当前线程获取锁失败,避免无限制的等待下去,也就避免了死锁.所谓公平锁,也就是先到先得. 如果多个线程获取锁的时候,就会去等待队列EntryList中去排队等待,如果是公平锁也就是排在前面的线程先获取到锁,排在后面的后获取到锁.//一个大房间有多间休息室。分析一下,为啥这样能解决死锁,对于synchronized,也就是没有获取到,就一直死等。
复制链接

扫一扫