多线程之ReentrantLock的基本方法使用(十七)

最新推荐文章于 2024-04-19 10:45:48 发布
最新推荐文章于 2024-04-19 10:45:48 发布
阅读量388 收藏
点赞数
分类专栏： java之多线程学习笔记 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43861630/article/details/114698846
版权

1.getHoldCount方法

返回当前线程调用lock()方法的次数

package com.dome.lock.method;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author qb
 * @version 1.0
 * @Description
 * getHoldCount
 * @date 2021/3/11 14:16
 */
public class Test02 {


    static ReentrantLock lock = new ReentrantLock();

    public static void m1(){
        try{
            lock.lock();
            //打印调用lock的次数
            System.out.println(Thread.currentThread().getName()+"--hold count"+lock.getHoldCount());
            //调用m2，ReentrantLock是可重入锁
            m2();
        }finally {
            lock.unlock();
        }
    }

    public static void m2(){
        try{
            lock.lock();
            //打印调用lock的次数
            System.out.println(Thread.currentThread().getName()+"==hold count"+lock.getHoldCount());
        }finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {

        m1();
    /*
    main--hold count1
    main==hold count
     */
    }


}

在这里插入图片描述

二、getQueueLength方法

返回正等待获得锁的预估数

package com.dome.lock.method;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author qb
 * @version 1.0
 * @Description
 * @date 2021/3/11 14:22
 */
public class Test03 {

    static ReentrantLock lock = new ReentrantLock();

    public static void sm(){
        try{
            lock.lock();
            System.out.println(Thread.currentThread().getName()+"获得锁，执行方法，估计等待获得锁的线程数:" +lock.getQueueLength());
            Thread.sleep(1000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }


    public static void main(String[] args) {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                Test03.sm();
            }
        };
        //开启10个线程
        for (int i = 0; i < 10; i++) {
            new Thread(r).start();
        }
    }

}

在这里插入图片描述

三、 getWaitQueueLength

返回与Condition条件相关的等待的线程预估数


package com.dome.lock.method;

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

/**
 * @author qb
 * @version 1.0
 * @Description
 * getWaitQueueLength   返回与Condition条件相关的等待的线程预估数
 * @date 2021/3/11 14:29
 */
public class Test04 {

    static class Service{

        private ReentrantLock lock = new ReentrantLock();

        private Condition condition = lock.newCondition();  //

        public void waitMethod(){
            try{
                lock.lock();
                System.out.println(Thread.currentThread().getName()+"进入等待前，现在该condition条件上等待的线程预估数"+
                        lock.getWaitQueueLength(condition));
                condition.await();
            }catch (InterruptedException e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }

        public void notifyMethod(){

            try {
                lock.lock();
                condition.signalAll();
                System.out.println("唤醒所有等待后，condition条件上等待的线程预估数"+lock.getWaitQueueLength(condition));
            }finally {
                lock.unlock();
            }

        }

    }

    public static void main(String[] args) throws InterruptedException {
        Service service = new Service();
        Runnable r = new Runnable() {
            @Override
            public void run() {
                service.waitMethod();
            }
        };
        //创建10个线程
        for (int i = 0; i < 10; i++) {
            new Thread(r).start();
        }
        Thread.sleep(1000);
        service.notifyMethod();
    }

}

在这里插入图片描述

四、hasQueuedThread

查询参数指定的线程是否在等待获得锁

hasQueuedThreads 查询是否还有线程等待获得该锁

package com.dome.lock.method;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author qb
 * @version 1.0
 * @Description
 *
 * hasQueuedThread  查询参数指定的线程是否在等待获得锁
 *
 * hasQueuedThreads 查询是否还有线程等待获得该锁
 * @date 2021/3/11 14:38
 */
public class Test05 {

        static ReentrantLock lock = new ReentrantLock();

        public static void waitMethod(){
            try {
                lock.lock();
                System.out.println(Thread.currentThread().getName() + "获得了锁对象");
                Thread.sleep(1000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }finally {
                System.out.println(Thread.currentThread().getName() + "释放了锁对象----");
                lock.unlock();

            }
        }

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

            Runnable r = new Runnable() {
                @Override
                public void run() {
                    Test05.waitMethod();
                }
            };

            Thread[] threads = new Thread[6];

        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(r);
            threads[i].setName("thread - "+i);
            threads[i].start();
        }

        Thread.sleep(3000);
        //判断数组中的每个线程对象是否正在等待获得锁
        System.out.println(lock.hasQueuedThread(threads[0]));
        System.out.println(lock.hasQueuedThread(threads[1]));
        System.out.println(lock.hasQueuedThread(threads[2]));
        System.out.println(lock.hasQueuedThread(threads[3]));
        System.out.println(lock.hasQueuedThread(threads[4]));

        Thread.sleep(2000);
        //判断是否还有线程在等待获得该锁
        System.out.println(lock.hasQueuedThreads());

    }


}

在这里插入图片描述

五、hasWaiters

查询是否有线程正在等待指定的condition条件

package com.dome.lock.method;

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

/**
 * @author qb
 * @version 1.0
 * @Description
 *
 * hasWaiters  查询是否有线程正在等待指定的condition条件
 * @date 2021/3/11 14:49
 */
public class Test06 {

    static ReentrantLock lock = new ReentrantLock();  //锁

    static Condition condition = lock.newCondition();  //返回锁  条件

    static void  sm(){
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "lock .....");
            System.out.println("是否有线程正在等待当点condition条件?"+lock.hasWaiters(condition) +"--等待数量： "
                    +lock.getWaitQueueLength(condition));
            //超时后自动唤醒
            condition.await(new Random().nextInt(1000), TimeUnit.MILLISECONDS);

        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            System.out.println(Thread.currentThread().getName() +"超时唤醒,是否有线程正在等待当点condition条件?"+lock.hasWaiters(condition) +"--等待数量： "
                    +lock.getWaitQueueLength(condition));
            System.out.println(Thread.currentThread().getName() + "unlock...");
            lock.unlock();
        }
    }

    public static void main(String[] args) {

        Runnable r = new Runnable() {
            @Override
            public void run() {
                sm();
            }
        };

        for (int i = 0; i < 10; i++) {
            new Thread(r).start();
        }


    }


}

在这里插入图片描述

六、isHeldByCurrentThread

.isFair() 判断是否为公平锁
判断当前线程是否持有锁

package com.dome.lock.method;

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

/**
 * @author qb
 * @version 1.0
 * @Description
 *
 *
 * .isFair()  判断是否为公平锁
 *
 * .isHeldByCurrentThread判断当前线程是否持有锁
 * @date 2021/3/11 15:01
 */
public class Test07 {


    static class Service{
        private ReentrantLock lock;

        public Service(boolean isFair){
            this.lock = new ReentrantLock(isFair);
        }

        public void ServiceMethod(){

            try{
                System.out.println("是否公平锁？ "+lock.isFair() + "---" +Thread.currentThread().getName() +
                        "调用lock前是否持有锁？ "+lock.isHeldByCurrentThread());
                lock.lock();
                System.out.println(Thread.currentThread().getName() + "调用lock方法后是否持有锁？ "+lock.isHeldByCurrentThread());
            }finally {
                if(lock.isHeldByCurrentThread()) {
                    lock.unlock();
                }
            }

        }

    }

    public static void main(String[] args) {

        Runnable r = new Runnable() {
            @Override
            public void run() {
                int num = new Random().nextInt();

                new Service(num % 2 == 0 ? true : false).ServiceMethod();
            }
        };

        for (int i = 0; i < 3; i++) {
            new Thread(r,"thread-"+i).start();
        }

    }

}

在这里插入图片描述

七、 isLocked() 判断当前锁是否被线程持有

package com.dome.lock.method;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author qb
 * @version 1.0
 * @Description
 * isLocked() 判断当前锁是否被线程持有
 *
 * @date 2021/3/11 15:09
 */
public class Test08 {

    static ReentrantLock lock = new ReentrantLock();

    static void sm(){

        try {
            System.out.println("lock方法之前--" + lock.isLocked());
            lock.lock();
            System.out.println("lock方法之后--" + lock.isLocked());
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            if(lock.isHeldByCurrentThread()){
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        System.out.println("11 lock 是否被线程持有?---"+lock.isLocked());

        new Thread(new Runnable() {
            @Override
            public void run() {
                sm();
            }
        }).start();

        Thread.sleep(3000);

        System.out.println("22 lock 是否被线程持有?---"+lock.isLocked());
    }

}

在这里插入图片描述

离别又见离别
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程系列(九) -ReentrantLock常用方法详解
程序员志哥的博客
02-26 1208
在上一篇文章中，我们介绍了ReentrantLock类的一些基本用法，今天我们重点来介绍一下ReentrantLock其它的常用方法，以便对ReentrantLock类的使用有更深入的理解。
Java并发编程之ReentrantLock
qq_42964601的博客
01-31 149
ReentrantLock 相对于 synchronized 它具备如下特点 可中断 可以设置超时时间 可以设置为公平锁 支持多个条件变量 与 synchronized 一样，都支持可重入 基本语法 可重入 可重入是指同一个线程如果首次获得了这把锁，那么因为它是这把锁的拥有者，因此有权利再次获取这把锁 如果是不可重入锁，那么第二次获得锁时，自己也会被锁挡住 输出 可打断 示例 输出 注意如果是不可中断模式，那么即使使用了 interrupt 也不会让等待中断 输出 锁超时 立刻失败
ReentrantLock详解
最新发布
超级博客
04-19 676
ReentrantLock 是 Java 并发包（java.util.concurrent.locks）中的一个可重入锁实现，它提供了比 synchronized 关键字更灵活、功能更丰富的线程同步机制。ReentrantLock类内部总共存在Sync、NonfairSync、FairSync三个类，NonfairSync（非公平锁）与FairSync（公平锁）类继承自Sync类，Sync类继承自AbstractQueuedSynchronizer抽象类。
ReentrantLock介绍及使用(超详细)
热门推荐
Mr.绵羊的知识星球
02-17 1万+
1. Reentrantlock介绍及使用 2. 公平锁和非公平锁 3. Reentrantlock的使用案例 4. Reentrantlock使用时注意事项
ReentrantLock 锁详解
m0_37235955的博客
04-27 3335
ReentrantLock 支持公平锁和非公平锁，可重入锁 ReentrantLock的底层是通过 **AQS[链接]**实现。 一、BAT 大厂的面试题 **【1】**什么是可重入，什么是可重入锁? 它用来解决什么问题? 【2】ReentrantLock 的核心是 AQS，那么它怎么来实现的，继承吗? 说说其类内部结构关系。 【3】ReentrantLock 是如何实现公平锁的? 【4】ReentrantLock 是如何实现非公平锁的? 【5】ReentrantLock 默认实现的是公平还是非公平锁.
Java 中的Lock锁对象(ReentrantLock/ReentrantReadWriteLock)详解
swadian2008的博客
08-29 3118
当有线程获取读锁时，如果当前没有线程持有写锁，则读锁将立即被获取，读锁计数器加一，表示当前有一个线程持有读锁。在 getValue() 方法中，线程会获取锁，返回共享变量 value 的值，最后释放锁。例如，如果一个线程在尝试获取锁的过程中遇到了饥饿现象（即一直获取不到锁），那么系统可能会采用类似于睡眠的方式，让该线程暂时让出 CPU 资源，等待一段时间后再次尝试获取锁。接着，它获取读锁，释放写锁，这样就实现了锁降级。这是因为写锁是独占锁，不能被多个线程同时持有，而读锁是共享锁，可以被多个线程同时持有。
Android多线程之同步锁的使用
08-29
Android多线程之同步锁的使用 Android多线程之同步锁的使用是Android应用程序开发中非常重要的一部分。多线程编程可以提高应用程序的性能和响应速度，但是它也带来了线程安全的问题。同步锁是解决线程安全问题的...
java基本教程之synchronized关键字 java多线程教程
09-04
【Java基本教程之synchronized关键字】在Java编程中，synchronized是用于控制多线程并发访问共享资源的关键字，确保了线程的安全性。本文将深入讲解synchronized的原理、基本规则以及其在方法和代码块中的应用。 1....
Java实现多线程同步五种方法详解
08-19
Java实现多线程同步五种方法...Java实现多线程同步可以通过五种方法实现，包括使用synchronized关键字、Lock接口、volatile关键字、Atomic类和并发集合等。每种方法都有其优缺点，需要根据实际情况选择合适的同步机制。
Java多线程中Lock锁的使用总结
08-18
Java多线程中Lock锁的使用总结 Java多线程中Lock锁的使用总结主要介绍了Java多线程中Lock锁的使用总结，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值。 知识点1: Java多线程中的...
Android 多线程处理之多线程详解
09-01
不过，本文主要讨论使用`Thread`和`Handler`进行多线程处理。 1. **直接使用Thread启动新线程**：通过继承`Thread`类或实现`Runnable`接口，创建一个新的线程。然而，直接在新线程中操作UI会导致错误。例如： ```...
ReentrantLock与synchronized区别
03-02
java语言 并发编程 ReentrantLock与synchronized区别 详解
ReentrantLock介绍
WYSCODER的博客
05-15 3848
ReentrantLock介绍
重入锁ReentrantLock详解
贾欣晓的博客
08-07 1227
重入锁ReentrantLock，顾名思义，就是支持重进入的锁，。除此之外，该锁的还支持获取锁时的公平和非公平性选择。在AQS实现中，当一个线程调用Mutex的lock()方法获取锁之后，如果再次调用lock()方法，则该线程将会被自己所阻塞，原因是Mutex在实现tryAcquire(int acquires)方法时没有考虑占有锁的线程再次获取锁的场景，。简单的说，Mutex是一个不支持重进入的锁。......
ReentrantLock 可重入锁的使用及原理
瞎叨叨的一天的博客
07-07 1139
ReentrantLock 是一个可重入的并且可非阻塞获取的锁
图解ReentrantLock公平锁和非公平锁实现
m0_73311735的博客
10-13 3864
ReentrantLock是Java并发中十分常用的一个类，具备类似synchronized锁的作用。但是相比synchronized, 它具备更强的能力，同时支持公平锁和非公平锁。指多个线程按照申请锁的顺序来获取锁，线程直接进入队列中排队，队列中的第一个线程才能获得锁。多个线程加锁时直接尝试获取锁，能抢到锁到直接占有锁，抢不到才会到等待队列的队尾等待。那ReentrantLock中具体是怎么实现公平和非公锁的呢？它们之间又有什么优缺点呢？本文就带大家一探究竟。
ReentrantLock的使用
学渣的博客
05-28 585
一、初识ReentrantLock（ReentrantLock 实现了Lock interface） import java.util.concurrent.locks.ReentrantLock; /** * Created by haicheng.lhc on 17/05/2017. * * @author haicheng.lhc * @date 2017/05/17 */ public class ReentrantLockTest extends Thread { pu.
重入锁ReentrantLock常用方法（三）
Morgan_Xiang的专栏
06-05 2050
1. isHeldByCurrentThread()    查询当前线程是否保持锁定。    isLocked()    查询是否存在任意线程保持此锁定。public class ReentrantLockMethodTest7 { private ReentrantLock lock = new ReentrantLock(); public void testMethod(...
生产者消费者问题的java实现
longshengguoji的专栏
11-29 5043
生产者和消费者是多线程经典的问题，生产者和消费者问题的核心是同步的问题，同步问题的核心是要保证同一个资源被多个线程并发访问时的完整性，常用的方法是采用信号或加锁机制，保证资源在任一时刻只能被一个线程访问。这一问题用java来实现的话主要有4种方式。1.wait()/notify()；2.await()/signal(); 3.blockingQuene 4.PipedInputStream/pip
Java多线程之ReentrantLock与Condition - 平凡希 - 博客园1
08-03
Java多线程之ReentrantLock与Condition ReentrantLock是一个可重入的互斥锁，又被称为“独占锁”。它是Java中实现锁的一种方式，具有和synchronized相同的并发性和内存语义，但是还提供了一些额外的特性，比如锁...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值