首页 > 其他分享 >多线程系列(九) -ReentrantLock常用方法详解

多线程系列(九) -ReentrantLock常用方法详解

时间：2024-02-26 11:34:50浏览次数：20  
标签：ThreadName Thread lock ReentrantLock 详解 线程 new 多线程 public

一、简介

在上一篇文章中，我们介绍了ReentrantLock类的一些基本用法，今天我们重点来介绍一下ReentrantLock其它的常用方法，以便对ReentrantLock类的使用有更深入的理解。

二、常用方法介绍

2.1、构造方法

ReentrantLock类有两个构造方法，核心源码内容如下：

/**
 * 默认创建非公平锁
 */
public ReentrantLock() {
    sync = new NonfairSync();
}

/**
 * fair为true表示是公平锁，fair为false表示是非公平锁
 */
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

相比于synchronized同步锁，ReentrantLock有一个很大的特点，就是开发人员可以手动指定采用公平锁机制还是非公平锁机制。

公平锁：顾名思义，就是每个线程获取锁的顺序是按照线程排队的顺序来分配的，最前面的线程总是最先获取到锁。

  • 优点：所有的线程都有机会得到资源
  • 缺点：公平锁机制实现比较复杂，程序流程比较多，执行速度比较慢

非公平锁：每个线程获取锁的顺序是随机的，并不会遵循先来先得的规则，任何线程在某时刻都有可能直接获取并拥有锁，之前介绍的synchronized其实就是一种非公平锁

  • 优点：公平锁机制实现相对比较简单，程序流程比较少，执行速度比较快
  • 缺点：有可能某些线程一直拿不到锁，导致饿死

ReentrantLock默认的构造方法是非公平锁，如果想要构造公平锁机制，只需要传入true就可以了。

示例代码如下：

public static void main(String[] args) {
    // 创建公平锁实现机制
    Lock lock = new ReentrantLock(true);

    // 创建5个线程
    for (int i = 0; i < 5; i++) {
        new Thread(new Runnable() {

            @Override
            public void run() {
                System.out.println("ThreadName：" + Thread.currentThread().getName() + ", 启动了!");

                // 尝试获取锁
                lock.lock();
                try {
                    System.out.println("ThreadName：" + Thread.currentThread().getName() + ", 获得锁!");
                } finally {
                    lock.unlock();
                }
            }
        }).start();
    }
}

运行一下程序，结果如下：

ThreadName：Thread-0, 启动了!
ThreadName：Thread-1, 启动了!
ThreadName：Thread-0, 获得锁!
ThreadName：Thread-1, 获得锁!
ThreadName：Thread-2, 启动了!
ThreadName：Thread-2, 获得锁!
ThreadName：Thread-3, 启动了!
ThreadName：Thread-3, 获得锁!
ThreadName：Thread-4, 启动了!
ThreadName：Thread-4, 获得锁!

从日志上可以看到，启动顺序为0,1,2,3,4，获取锁的顺序为0,1,2,3,4，启动与获取锁的排队机制一致。

假如我们构造方法里面的把true改成false，也就是非公平锁机制，在看看运行效果，结果如下：

ThreadName：Thread-1, 启动了!
ThreadName：Thread-2, 启动了!
ThreadName：Thread-1, 获得锁!
ThreadName：Thread-0, 启动了!
ThreadName：Thread-2, 获得锁!
ThreadName：Thread-3, 启动了!
ThreadName：Thread-3, 获得锁!
ThreadName：Thread-0, 获得锁!
ThreadName：Thread-4, 启动了!
ThreadName：Thread-4, 获得锁!

从日志上可以看到，启动顺序为1,2,0,3,4，获取锁的顺序为1,2,3,0,4，线程启用与获取锁的顺序不一致。

从实际的运行结果看，非公平锁要比公平锁执行速度要快一些，当线程数越多的时候，效果越明显。

2.2、核心方法

ReentrantLock类的核心方法就比较多了，如下表！

方法 描述
public void lock() 阻塞等待获取锁；不允许Thread.interrupt中断，即使检测到Thread.isInterrupted一样会继续尝试
public void lockInterruptibly() 当前线程未被中断，则获取锁；允许在等待时由其它线程调用等待线程的Thread.interrupt方法来中断等待线程的等待而直接返回
public boolean tryLock() 尝试申请一个锁，在成功获得锁后返回true，否则，立即返回false
public boolean tryLock(long timeout, TimeUnit unit) 在一段时间内尝试申请一个锁，在成功获得锁后返回true，否则，立即返回false
public void unlock() 释放锁
public Condition newCondition() 条件实例，用于线程等待/通知模式
public int getHoldCount() 获取当前线程持有此锁的次数
public boolean isHeldByCurrentThread() 检测是否被当前线程持有
public boolean isLocked() 查询此锁是否由任意线程持有
public final boolean isFair() 如果是公平锁返回true，否则返回false
public final boolean hasQueuedThreads() 查询是否有线程正在等待
public final boolean hasQueuedThread(Thread thread) 查询给定线程是否正在等待获取此锁
public final int getQueueLength() 获取正等待获取此锁的线程数
public boolean hasWaiters(Condition condition) 是否存在正在等待并符合相关给定条件的线程
public int getWaitQueueLength(Condition condition) 正在等待并符合相关给定条件的线程数量

虽然方法很多，但是实际上常用方法就那么几个，下面我们主要抽一些常用的方法进行介绍。

2.2.1、tryLock 方法

lock()、lockInterruptibly()、tryLock()和tryLock(long timeout, TimeUnit unit)这几个方法，目的其实是一样的，都是为了获取锁，只是针对不同的场景做了单独的处理。

lock()：阻塞等待获取锁，如果没有获取到会一直阻塞，即使检测到Thread.isInterrupted一样会继续尝试；

  • lockInterruptibly()：同样也是阻塞等待获取锁，稍有不同的是，允许在等待时由其它线程调用等待线程的Thread.interrupt方法来中断等待线程的等待而直接返回
  • tryLock()：表示尝试申请一个锁，在成功获得锁后返回true，否则，立即返回false，不会阻塞等待获取锁
  • tryLock(long timeout, TimeUnit unit)：表示在一段时间内尝试申请一个锁，在成功获得锁后返回true，否则，立即返回false

其中tryLock(long timeout, TimeUnit unit)方法的应用最广泛，因为它能防止程序发生死锁，即使在一段时间内没有获取锁，也会自动退出，不会一直阻塞。

我们可以看一个简单的例子，如下！

public static void main(String[] args) {
    // 创建公平锁实现机制
    Lock lock = new ReentrantLock();

    // 创建5个线程
    for (int i = 0; i < 5; i++) {
        new Thread(new Runnable() {

            @Override
            public void run() {
                boolean flag = false;
                try {
                    // 尝试3秒内获取锁
                    flag = lock.tryLock(3, TimeUnit.SECONDS);
                    if(flag){
                        System.out.println("ThreadName：" + Thread.currentThread().getName() + ", 获取到锁");
                        // 模拟进行5秒的业务操作
                        Thread.sleep(5000);
                    } else {
                        System.out.println("ThreadName：" + Thread.currentThread().getName() + ", 经过3秒钟的尝试未获取到锁，放弃尝试");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    if (flag){
                        System.out.println("ThreadName：" + Thread.currentThread().getName() + ", 释放对象");
                        lock.unlock();
                    }
                }
            }
        }).start();
    }
}

运行一下程序，结果如下：

ThreadName：Thread-0, 获取到锁
ThreadName：Thread-3, 经过3秒钟的尝试未获取到锁，放弃尝试
ThreadName：Thread-1, 经过3秒钟的尝试未获取到锁，放弃尝试
ThreadName：Thread-2, 经过3秒钟的尝试未获取到锁，放弃尝试
ThreadName：Thread-4, 经过3秒钟的尝试未获取到锁，放弃尝试
ThreadName：Thread-0, 释放对象

可以很清晰的看到，非Thread-0线程尝试了 3 秒没有获取到锁，自动放弃；如果换成lock()方法进行获取锁，线程Thread-0如果不释放锁，其它线程会一直阻塞。

2.2.2、unlock 方法

unlock()方法也是常用方法，表示释放锁。当获取到锁之后，一定要手动释放锁，否则可能会造成其它程序执行出现问题，通常用在finally方法块里面。

// 阻塞等待获取锁
lock.lock();
try {
    // 业务操作...
} finally {
	// 一定要释放锁
    lock.unlock();
}
2.2.3、newCondition 方法

newCondition()方法，在上文中介绍过，ReentrantLock和Condition结合，可以实现线程之间的等待／通知模型。

简单的示例，如下！

public class Counter {

    private final Lock lock = new ReentrantLock();

    private Condition condition = lock.newCondition();

    private int count;

    public void await(){
        // 加锁
        lock.lock();
        try {
            // 让当前线程进入等待状态，并释放锁
            condition.await();
            System.out.println("await等待结束，count：" + getCount());
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            // 释放锁
            lock.unlock();
        }
    }


    public void signal(){
        // 加锁
        lock.lock();
        try {
            count++;
            // 唤醒某个等待线程
            condition.signal();
            System.out.println("signal 唤醒通知完毕");
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            // 释放锁
            lock.unlock();
        }
    }

    public int getCount() {
        return count;
    }
}

public class MyThreadTest {

    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        // 先启动执行等待的线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                counter.await();
            }
        }).start();

        Thread.sleep(3000);

        // 过3秒，再启动执行通知的线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                counter.signal();
            }
        }).start();
    }
}

运行一下程序，结果如下：

signal 唤醒通知完毕
await等待结束，count：1
2.2.4、getHoldCount 方法

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

示例代码如下：

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

    new Thread(new Runnable() {

        @Override
        public void run() {
            // 第一次获取锁
            lock.lock();
            try {
                System.out.println("ThreadName：" + Thread.currentThread().getName() + ", getHoldCount：" +  lock.getHoldCount());

                // 第二次获取锁
                lock.lock();
                try {
                    System.out.println("ThreadName：" + Thread.currentThread().getName() + ", getHoldCount：" +  lock.getHoldCount());
                } finally {
                    lock.unlock();
                }
            } finally {
                lock.unlock();
            }
        }
    }).start();
}

运行一下程序，结果如下：

ThreadName：Thread-0, getHoldCount：1
ThreadName：Thread-0, getHoldCount：2

侧面也证明了一点，ReentrantLock和synchronized一样，锁都具有可重入特性，也就是说同一个线程多次调用同一个ReentrantLock的lock()方法，可以再次进入方法体，无需阻塞等待。

2.2.5、isLocked 方法

isHeldByCurrentThread()和isLocked()方法都是用于检测锁是否被持有。

其中isHeldByCurrentThread()方法表示此锁是否由当前线程持有；isLocked()方法表示此锁是否由任意线程持有。

我们看一个简单的示例，如下：

public class Counter {

    private ReentrantLock lock = new ReentrantLock();

    public void methodA(){
        lock.lock();
        try {
            System.out.println("ThreadName：" + Thread.currentThread().getName() + ", 当前线程是否持有锁:" +  lock.isHeldByCurrentThread());
            System.out.println("ThreadName：" + Thread.currentThread().getName() + ", 任意线程是否持有锁:" +  lock.isLocked());
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void methodB(){
        System.out.println("ThreadName：" + Thread.currentThread().getName() + ", 当前线程是否持有锁:" +  lock.isHeldByCurrentThread());
        System.out.println("ThreadName：" + Thread.currentThread().getName() + ", 任意线程是否持有锁:" +  lock.isLocked());
    }
}

public class MyThreadTest {

    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

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

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

运行一下程序，结果如下：

ThreadName：Thread-0, 当前线程是否持有锁:true
ThreadName：Thread-0, 任意线程是否持有锁:true
ThreadName：Thread-1, 当前线程是否持有锁:false
ThreadName：Thread-1, 任意线程是否持有锁:true

从日志结果很容易理解，Thread-0线程持有锁，因此调用isHeldByCurrentThread()和isLocked()方法，返回结果都是true；Thread-1线程没有持有锁，因此isHeldByCurrentThread()方法返回false，isLocked()方法返回true

2.2.6、isFair 方法

isFair()方法用来获取此锁是否公平锁。

简单的示例，如下：

ReentrantLock lock = new ReentrantLock(true);
System.out.println("是否公平锁:" +  lock.isFair());

输出结果如下：

是否公平锁:true

ReentrantLock默认的是非公平锁，当通过构造方法显式传入true时，采用的是公平锁机制

2.2.5、hasQueuedThreads 方法

hasQueuedThreads()和hasQueuedThread()方法都用于查询是否有线程等待获取锁，稍有不同的是：hasQueuedThreads()方法表示查询是否有线程正在等待获取锁；hasQueuedThread()方法表示查询给定线程是否正在等待获取此锁。

另外还有一个getQueueLength()方法，表示获取正等待获取此锁的线程数。

我们看一个简单的示例，如下：

public static void main(String[] args) throws InterruptedException {
    ReentrantLock lock = new ReentrantLock();

    Thread threadA = new Thread(new Runnable() {
        @Override
        public void run() {
            lock.lock();
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    });
    threadA.start();

    Thread threadB = new Thread(new Runnable() {
        @Override
        public void run() {
            lock.lock();
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    });
    threadB.start();

    // 等待线程都启动完毕
    Thread.sleep(1000);

    System.out.println("查询是否有线程正在等待：" + lock.hasQueuedThreads());
    System.out.println("查询处于等待的线程数：" + lock.getQueueLength());
    System.out.println("threadA 是否处于等待状态：" +  lock.hasQueuedThread(threadA));
    System.out.println("threadB 是否处于等待状态：" +  lock.hasQueuedThread(threadB));
}

输出结果如下：

查询是否有线程正在等待：true
查询处于等待的线程数：1
threadA 是否处于等待状态：false
threadB 是否处于等待状态：true

从日志上可以清晰的看到，线程threadA先获取了锁，线程threadB处于等待获取锁的状态，处于等待的线程数为1。

2.2.7、hasWaiters 方法

hasWaiters()和getWaitQueueLength()方法，支持传入condition条件对象进行查询。

其中hasWaiters()方法表示查询是否存在正在等待并符合相关给定条件的线程；getWaitQueueLength()方法表示查询正在等待并符合相关给定条件的线程数量。

我们看一个简单的示例，如下：

public static void main(String[] args) throws InterruptedException {
    ReentrantLock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    Thread threadA = new Thread(new Runnable() {
        @Override
        public void run() {
            lock.lock();
            try {
                condition.await();
                System.out.println("await等待结束");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    });
    threadA.start();

    // 睡眠1秒
    Thread.sleep(1000);

    Thread threadB = new Thread(new Runnable() {
        @Override
        public void run() {
            lock.lock();
            try {
                System.out.println("是否存在正在等待并符合相关给定条件的线程：" + lock.hasWaiters(condition));
                System.out.println("正在等待并符合相关给定条件的线程数量：" + lock.getWaitQueueLength(condition));
                Thread.sleep(5000);
                condition.signal();
                System.out.println("signal 唤醒通知完毕");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    });
    threadB.start();
}

输出结果如下：

是否存在正在等待并符合相关给定条件的线程：true
正在等待并符合相关给定条件的线程数量：1
signal 唤醒通知完毕
await等待结束

需要注意的是，调用condition对象的方法，必须要在获取锁的方法体内执行。

三、小结

本文主要围绕ReentrantLock类的核心方法进行了一些知识总结，其中最常用方法的主要就两个，tryLock(long timeout, TimeUnit unit)和unlock()，通过它可以实现线程同步安全的效果。

本文内容比较多，如果有不正之处，请多多谅解，并欢迎批评指出。

四、参考

1、https://www.cnblogs.com/xrq730/p/4855538.html

标签：ThreadName,Thread,lock,ReentrantLock,详解,线程,new,多线程,public
From： https://www.cnblogs.com/dxflqm/p/18033936

相关文章

  • 实例详解数据库的游标管理
    本文分享自华为云社区《GaussDB数据库SQL系列-游标管理》，作者：酷哥。一、前言在数据库中，游标（cursor）是一种非常重要的工具，用于在数据库查询结果集中进行定位和操作。游标提供了一种在多行数据结果集中逐行处理每一行的机制，允许开发人员对每一行的数据进行操作，如检索、过滤、修改等......
  • 机器学习策略篇：详解正交化（Orthogonalization）
    正交化这是一张老式电视图片，有很多旋钮可以用来调整图像的各种性质，所以对于这些旧式电视，可能有一个旋钮用来调图像垂直方向的高度，另外有一个旋钮用来调图像宽度，也许还有一个旋钮用来调梯形角度，还有一个旋钮用来调整图像左右偏移，还有一个旋钮用来调图像旋转角度之类的。电视设计......
  • 个人在学习过程中对多线程和异步的理解
    私人对于异步与多线程的理解前言​ 异步与多线程都是并发问题的一种解决方式，但是异步是程序员层面，线程是操作系统层面的。​ 其次，异步与线程解决并发问题的实现方式和目的是不同的。下面举一个不太贴切的例子。如果把线程当作一条单行道，那么多线程就是通过扩展多条道路从而实现......
  • k8s-flannel网络详解
    1，网卡k8s安装完以后，查看k8s各node节点的网卡，会发现多了4个网卡docker0,flannel.1,cni0,veth,其中docker0纯粹是因为安装了docker服务才生成的网卡，和k8s集群是的逻辑架构没关系1.1docker0网卡docker0充当了一个网桥的功能，就是相当于一个集线器的功能，一个口收到信号......
  • 核心子方法1: prepareRefresh()方法详解
    1、设置容器的启动时间:this.startupDate=System.currentTimeMillis();2、设置活跃状态为true:this.closed.set(false);3、设置关闭状态为false:this.active.set(true);4、获取Environment对象，并加载当前系统的属性值到Environment对象中:getEnvironment().validateRequired......
  • 【KingbaseES】sys_restore命令详解及示例
    原文地址：https://blog.csdn.net/sinat_36528886/article/details/134491475【KingbaseES】sys_restore命令详解及示例一、概述二、语法一、概述sys_restore—从一个由sys_dump创建的归档文件恢复一个KingbaseES数据库sys_restore是一个用来从sys_dump创建的非文本格式......
  • 【转载】docker save load export import区别详解
    【转载】dockersaveloadexportimport区别详解https://www.cnblogs.com/dingjiaoyang/p/16571840.html1、dockersave用来将一个或多个image打包保存。如：将本地镜像库中的image1和image2打包到images.tar中dockersave-oimages.tagimage1:v1image2:v1dockersave也可......
  • 刘铁猛C#学习笔记12 参数种类详解
    一、值参数（传值参数、值传递）指参数的种类为值参数，而非参数数据类型为值类型1.值类型的传值参数类似一个新声明的局部变量，或传进来的实参的一个副本可以在方法体内重现赋值，但其在方法体内被赋值时，不会影响传进来的本体 2.引用类型的传值参数引用类型变量存储的是实例......
  • pip install 命令详解
    pipinstall命令用于安装Python包，支持从多种源安装包1.通过pipinstall-h命令查看帮助文档总共包括：1.usage2. Description3. InstallOptions4. PackageIndexOptions5. GeneralOptions: 1.用法（usage）：Usage:pipinstall[options]<requirementspecifie......
  • 刘铁猛C#学习笔记4 方法详解
    方法的由来C++中用两个冒号访问命名空间如：std::cout<<"Hello,World!";“方法”是一个面向对象的概念，当一个函数作为类的成员出现时，就被称之为方法方法也可以称作“成员函数”C++中对类的声明放在.h文件中，而类的定义放在.cpp文件中c#中类的声明和定义是放在一起的 C+......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99