JAVA并发编程（六）-ReentrantLock

最新推荐文章于 2024-05-16 15:30:42 发布
最新推荐文章于 2024-05-16 15:30:42 发布
阅读量856 收藏 24
点赞数 9
文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_36531037/article/details/136007268
版权

文章目录

🐠一、多把锁

代码：

public class ManyLocks {

    public static void main(String[] args) {


        BigRoom bigRoom = new BigRoom();
        new Thread(() -> {
            bigRoom.study();
        },"小女").start();


        new Thread(() -> {
            bigRoom.sleep();
        },"小南").start();




    }
}

@Slf4j(topic = "BigRoom")
class BigRoom
{

    private final Object studyRoom=new Object();

    private final Object bedRoom=new Object();

    public void study(){
        synchronized (studyRoom) {
            log.debug("study 2小时");
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public void sleep(){
        synchronized (bedRoom) {
            log.debug("sleeping 2小时");
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

结果：
在这里插入图片描述

  这里我们可以看到小南小女分别在两间房间里头，小南在睡觉，小女在学习，这就会存在多把锁的情况。

🐟二、死锁

1、死锁演示

  有这样的情况：一个线程需要同时获得多把锁，这时就容易发生死锁。

  例如t1线程获得A对象的锁，接下来又想获取B对象的锁。
  t2线程获得到B对象的锁，接下来又想获取A对象的锁。

同样是小南小女，我们来看一下他们的这种情况。

public class ManyLocks {

    public static void main(String[] args) {


        BigRoom bigRoom = new BigRoom();
        new Thread(() -> {
            bigRoom.study();
        },"小女").start();


        new Thread(() -> {
            bigRoom.sleep();
        },"小南").start();




    }
}

@Slf4j(topic = "BigRoom")
class BigRoom
{

    private final Object studyRoom=new Object();

    private final Object bedRoom=new Object();

    public void sleep(){
        synchronized (studyRoom) {
            log.debug("study 2小时");
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
                synchronized (bedRoom){
                    log.debug("sleeping 2小时");
                    try {
                        TimeUnit.SECONDS.sleep(2);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }

                }

        }
    }

    public void study(){
        synchronized (bedRoom) {
            log.debug("sleeping 2小时");
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            synchronized (studyRoom){
                log.debug("study 2小时");

                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

            }
        }
    }
}

结果：
在这里插入图片描述
小女线程在学习了两个小时后，想去bedroom睡觉，却发现小南在bedroom当中占用着锁。而小南在bedroom睡觉两个小时之后，想去studyroom学习，却发现小女在studyroom中学习，并且占用着锁。这样就会导致小南和小女各自占用着锁都不释放，从而导致线程一直无法结束，造成死锁的现象。

2、定位死锁

首先我们打开jconsole
在这里插入图片描述
然后我们连接到当前正在跑的进程，我们可以点击检测死锁
在这里插入图片描述

🐬三、活锁

活锁出现在两个线程互相改变对方的结束条件，最后谁也无法结束。

@Slf4j(topic = "TestLiveLock")
public class TestLiveLock {

    static volatile int count=10;

    public static void main(String[] args) {
        new Thread(() -> {
            while(count>0){
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

                count--;
                log.debug("count:{}",count);
            }
        },"t1"
                ).start();

        new Thread(() -> {
            while(count<20){
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

                count++;

                log.debug("count:{}",count);
            }
        },"t2"
        ).start();
    }

}

执行结果：
在这里插入图片描述
我们看到这里我们有t1和t2两个线程，当count>0的时候t1线程一直在减一，当count<20的时候t2线程一直在加一，这样就会导致两个线程一直都无法结束。这就是活锁。

🐳 四、ReentrantLock简介

  在Java中，ReentrantLock 是一个可重入的互斥锁，它提供了与synchronized关键字类似的线程同步机制。相对于synchronized块，ReentrantLock 提供了更灵活的锁定机制，并支持更多的功能。
相对于synchronized它具备如下特点
1、可中断
2、可以设置超时时间
3、可以设置为公平锁
4、支持多个条件变量

与synchronized一样，都支持可重入

语法：

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

🐋五、ReentrantLock可重入

演示代码：

@Slf4j(topic = "TestReentrantLock")
public class TestReentrantLock {


    private static ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) {

        lock.lock();
        try {

            log.debug("进入主方法");

            m1();
        } finally {
            lock.unlock();
        }
    }

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

    public static void m2() {
        lock.lock();

        try {
            log.debug("进入m2");

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

执行结果：
在这里插入图片描述

🦈六、ReentrantLock可打断

演示代码：

@Slf4j(topic = "TestReentrantLock")
public class TestReentrantLock {


    private static ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) {

        Thread t1 = new Thread(() -> {
            try {
                lock.lockInterruptibly();
            } catch (InterruptedException e) {
                log.debug("老子不等了");
                return;
            }


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

        new Thread(() -> {
            log.debug("我拿到锁了");
            lock.lock();
        },"t2").start();


        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        t1.start();

        t1.interrupt();


    }}

结果：
在这里插入图片描述
这里可以看到t2线程一直拿着lock的锁不释放，当主线程去打断t1线程的时候就直接不等了，结束了t1线程。这里需要注意的是lock.lockInterruptibly();需要用try catch来进行包裹，这里catch处理的是当受到外部打断的时候，t1线程应该执行的动作。

🐊七、ReentrantLock锁超时

1、tryLock（）尝试获取锁

@Slf4j(topic = "TestReentrantLock")
public class TestReentrantLock {


    private static ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) {

         new Thread(() -> {

            log.debug("尝试获取锁");
            if (!lock.tryLock()) {
                log.debug("获取不到锁");
                return;
            }
            try {
                log.debug("获取到锁了");
            } finally {
                lock.unlock();
            }


        }, "t1").start();


    }
}

在这里插入图片描述

@Slf4j(topic = "TestReentrantLock")
public class TestReentrantLock {


    private static ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) {

        Thread thread = new Thread(() -> {

            log.debug("尝试获取锁");
            if (!lock.tryLock()) {
                log.debug("获取不到锁");
                return;
            }
            try {
                log.debug("获取到锁了");
            } finally {
                lock.unlock();
            }


        }, "t1");


        lock.lock();
        thread.start();


    }
}

结果：
在这里插入图片描述

2、tryLock（）锁超时

@Slf4j(topic = "TestReentrantLock")
public class TestReentrantLock {


    private static ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) {

        Thread thread = new Thread(() -> {

            log.debug("尝试获取锁");
            try {
                if (!lock.tryLock(1,TimeUnit.SECONDS)) {
                    log.debug("获取不到锁");
                    return;
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            try {
                log.debug("获取到锁了");
            } finally {
                lock.unlock();
            }


        }, "t1");


        lock.lock();
        thread.start();


    }
}

结果：
在这里插入图片描述
这里我们设置了t1线程在一秒后如果获取不到锁就会结束掉t1线程。
注意：这里lock.tryLock(1,TimeUnit.SECONDS)，需要用try catch来进行捕获，这里catch所处理的代码是当在等待的过程中被打断的时候，应当进行什么样的处理

🐅八、ReentrantLock公平锁

ReentrantLock默认是不公平的

private static ReentrantLock lock = new ReentrantLock(false);
在这里插入图片描述
公平锁一般没有必要，会降低并发度，后面分析原理时会讲解。

🐆九、ReentrantLock条件变量

在这里插入图片描述
代码演示：

@Slf4j(topic = "TestAwaitSignal")
public class TestAwaitSignal {
    static boolean hasCigaratte = false;

    static boolean hasTakeOut = false;

    static ReentrantLock ROOM = new ReentrantLock();


    //等待烟的休息室
    static Condition waitCigaratteSet = ROOM.newCondition();

    //等待外卖的休息室
    static Condition waitTakeOutSet = ROOM.newCondition();


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

        new Thread(() -> {

            ROOM.lock();
            try {
                log.debug("有烟没？[{}]", hasCigaratte);
                while (!hasCigaratte) {
                    log.debug("没有烟，先歇着");
                    try {
                        waitCigaratteSet.await();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }


                log.debug("有烟没？[{}]", hasCigaratte);

                if (hasCigaratte) {
                    log.debug("开始干活");
                } else {
                    log.debug("没干成活");
                }
            } finally {
                ROOM.unlock();
            }

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


        new Thread(() -> {
            ROOM.lock();
            try {
                log.debug("有外卖没？[{}]", hasTakeOut);


                try {
                    waitTakeOutSet.await();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }


                log.debug("有外卖没？[{}]", hasTakeOut);

                if (hasTakeOut) {
                    log.debug("开始吃饭");
                } else {
                    log.debug("没吃上饭 ");
                }
            } finally {
                ROOM.unlock();
            }

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


        TimeUnit.SECONDS.sleep(1);
        new Thread(() -> {
            ROOM.lock();
            try {
                hasTakeOut = true;
                waitTakeOutSet.signal();
                log.debug("来送外卖喽");
            } finally {
                ROOM.unlock();
            }
        }, "送外卖喽").start();


    }
}

结果：
在这里插入图片描述

imperfectsam
关注
  • 9
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
深入java并发编程，使用ReentrantLock和 Synchronized加锁
12-25
深入java并发编程，使用ReentrantLock和 Synchronized加锁
java并发编程1-9
03-22
java并发编程1-9，可解压，并发编程必看资料。 1 Java 并发编程实践基础 2 构建线程安全应用程序 3 使用JDK 并发包构建程序 4 使用开源软件 Amino 构建并发应用程序 5 数据冲突及诊断工具MTRAT 6 死锁 7 显示锁 ...
Java并发编程-ReentrantLock可重入锁
Java硬件工程师的博客
02-05 1690
目录1.ReentrantLock可重入锁概述2.可重入3.可打断4.锁超时5.公平锁6.条件变量 Condition 1.ReentrantLock可重入锁概述 相对于 synchronized 它具备如下特点 可中断 synchronized锁加上去不能中断，a线程应用锁，b线程不能取消掉它 可以设置超时时间 synchronized它去获取锁时，如果对方持有锁，那么它就会进入entryList一直等待下去。而可重入锁可以设置超时时间，规定时间内如果获取不到锁，就放弃锁 可以设置为公平锁 防止线程饥饿的
java并发编程---ReentrantLock公平锁实现原理
e891377的专栏
10-21 311
文章目录java并发编程---ReentrantLock公平锁实现原理先看非公平锁公平锁的实现 java并发编程—ReentrantLock公平锁实现原理 先看非公平锁 static final class NonfairSync extends Sync { final void lock() { if (compareAndSetState(0, 1))...
Java并发编程-ReentrantLock
Object的博客
11-14 106
Java并发编程-ReentrantLock 转载：https://www.cnblogs.com/iou123lg/p/9535710.html 转载理由：看看理论
java并发编程---ReentrantLock不可打断模式与可打断模式
e891377的专栏
03-07 1597
ReentrantLock可打断原理
并发编程-ReentrantLock解锁流程
痞子的博客
02-08 208
并发编程之ReentrantLock解锁流程 目录 并发编程之ReentrantLock解锁流程 一、解锁流程 二、代码执行流程 一、解锁流程 情景：线程t1持有锁，t2在park。然后t1释放锁，唤醒t2 解锁之前AQS（NonfairSync）的状态。重点关注waitStatus的值和当前线程拥有者。 图1 解...
Java并发编程 - AQS 之 ReentrantLock
牧码的博客
04-15 257
package com.mmall.concurrency.example.lock; import com.mmall.concurrency.annoations.ThreadSafe; import lombok.extern.slf4j.Slf4j; import java.util.concurrent.CountDownLatch; import java.util.concurr...
学习笔记(17):Java并发编程精讲-ReentrantLock的加锁解锁过程(一)
Charlven的博客
03-08 202
课程会讲解Java中并发相关技术的基础、原理和应用，从线程安全、线程(池)， 锁实现和并发容器等高并发Java实现，去深入理解在并发编程中， 一些最容易被忽视的点，这些点也是我在多年编程经验中实际用到， 对于每个小节小课均会有实际的场景应用为你呈现。 同时这些也是面试过程中面试官考察的重点，掌握这些点，面试和工作时，做到心中有货，不慌不乱，能够胜任。...
JUC并发编程八 并发架构--ReentrantLock
m0_37564426的博客
12-12 501
相比synchronized,ReentrantLock具备以下特点: 可中断 可以设置超长时间 可以设置为公平锁 可以支持多个条件变量 与synchronized一样,都支持可重入.
学习笔记(07):Java并发编程精讲-ReentrantLock的加锁解锁过程(一)
Kobe_1314的博客
02-23 232
课程会讲解Java中并发相关技术的基础、原理和应用，从线程安全、线程(池)， 锁实现和并发容器等高并发Java实现，去深入理解在并发编程中， 一些最容易被忽视的点，这些点也是我在多年编程经验中实际用到， 对于每个小节小课均会有实际的场景应用为你呈现。 同时这些也是面试过程中面试官考察的重点，掌握这些点，面试和工作时，做到心中有货，不慌不乱，能够胜任。...
学习笔记(19):Java并发编程精讲-ReentrantLock的加锁解锁过程(三)
Charlven的博客
03-15 151
课程会讲解Java中并发相关技术的基础、原理和应用，从线程安全、线程(池)， 锁实现和并发容器等高并发Java实现，去深入理解在并发编程中， 一些最容易被忽视的点，这些点也是我在多年编程经验中实际用到， 对于每个小节小课均会有实际的场景应用为你呈现。 同时这些也是面试过程中面试官考察的重点，掌握这些点，面试和工作时，做到心中有货，不慌不乱，能够胜任。...
java并发编程专题（五）----详解（JUC）ReentrantLock
08-18
主要介绍了java（JUC）ReentrantLock的的相关资料，文中讲解非常详细，实例代码帮助大家更好的理解和学习，感兴趣的朋友可以了解下
Java并发编程之显示锁ReentrantLock和ReadWriteLock读写锁
09-03
主要介绍了Java并发编程之显示锁ReentrantLock和ReadWriteLock读写锁,本文讲解了ReentrantLock概况、Lock接口、Lock使用、轮询锁的和定时锁、公平性、可中断获锁获取操作等内容,需要的朋友可以参考下
Java并发编程学习笔记
04-11
4、ReentrantLock底层实现和如何使用 5、Condition源码分析 6、ReentrantReadWriteLock底层实现原理 7、并发工具类CountDownLatch 、CyclicBarrier和Semaphore底层实现原理 8、线程池原理和如何使用线程池 9、...
jar包增量更新分析
junlaiyan的专栏
05-16 252
借助jdeps分析出jar包的增量文件
java实现拼图小游戏
monkey108的博客
05-16 617
本文主要提供用java实现的拼图小游戏源代码。
c【语言】了解指针，爱上指针（1）
最新发布
yzqy_的博客
05-16 899
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
命令执行漏洞（二）
XLbb的博客
05-15 903
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
狂神说java-juc并发编程
09-23
狂神说java-juc并发编程是指狂神在讲解Java并发编程时提到了Java Util Concurrent（简称JUC）这个包。JUC是Java中用于处理并发编程的三个包之一，它包含了一系列的并发工具类和线程安全的集合类。其中，java.util....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值