欢迎您的访问
专注于分享最有价值的互联网技术干货

二十二、ReentrantLock使用

几个T的资料等你来白嫖
双倍快乐

ReentrantLock 使用

1. 前言

本节内容主要是对 ReentrantLock 的使用进行讲解,之前对于 Lock 接口进行了讲解,ReentrantLock 是 Lock 接口的常用实现子类,占据着十分重要的地位。本节内容的知识点如下:

  • ReentrantLock 基本方法的使用,即 lock 与 unlock 方法的使用,这是最基础的方法使用,为重点内容;
  • ReentrantLock lockInterruptibly 与 tryLock 方法的使用,也是经常使用到的方法,为本节重点内容;
  • ReentrantLock 公平锁与非公平锁的使用,也是本节的重点内容;
  • ReentrantLock 其他方法的介绍与使用。

通篇来看,ReentrantLock 所有的知识点均为重点内容,是必须要掌握的内容。

2. ReentrantLock 介绍

ReentrantLock 在 Java 中也是一个基础的锁,ReentrantLock 实现 Lock 接口提供一系列的基础函数,开发人员可以灵活的使用函数满足各种复杂多变应用场景。

定义:ReentrantLock 是一个可重入且独占式的锁,它具有与使用 synchronized 监视器锁相同的基本行为和语义,但与 synchronized 关键字相比,它更灵活、更强大,增加了轮询、超时、中断等高级功能。

ReentrantLock,顾名思义,它是支持可重入锁的锁,是一种递归无阻塞的同步机制。除此之外,该锁还支持获取锁时的公平和非公平选择。

公平性:ReentrantLock 的内部类 Sync 继承了 AQS,分为公平锁 FairSync 和非公平锁 NonfairSync。

如果在绝对时间上,先对锁进行获取的请求一定先被满足,那么这个锁是公平的,反之,是不公平的。公平锁的获取,也就是等待时间最长的线程最优先获取锁,也可以说锁获取是顺序的。

ReentrantLock 的公平与否,可以通过它的构造函数来决定。

3. ReentrantLock 基本方法 lock 与 unlock 的使用

我们使用一个之前涉及到的 synchronized 的场景,通过 lock 接口进行实现。

场景回顾

  • 创建两个线程,创建方式可自选;
  • 定义一个全局共享的 static int 变量 count,初始值为 0;
  • 两个线程同时操作 count,每次操作 count 加 1;
  • 每个线程做 100 次 count 的增加操作。

结果预期:获取到的结果为 200。之前我们使用了 synchronized 关键字和乐观锁 Amotic 操作进行了实现,那么此处我们进行 ReentrantLock 的实现方式。

实现步骤

  • step 1 :创建 ReentrantLock 实例,以便于调用 lock 方法和 unlock 方法;
  • step 2:在 synchronized 的同步代码块处,将 synchronized 实现替换为 lock 实现。

实例

public class DemoTest{
    private static int count = 0; //定义count = 0
    private static ReentrantLock lock = new ReentrantLock();//创建 lock 实例
    public static void main(String[] args) {
        for (int i = 0; i < 2; i++) { //通过for循环创建两个线程
            new Thread(new Runnable() {
                @Override
                public void run() {
                    //每个线程让count自增100次
                    for (int i = 0; i < 100; i++) {
                        try {
                            lock.lock(); //调用 lock 方法
                            count++;
                        } finally {
                            lock.unlock(); //调用unlock方法释放锁
                        }
                    }
                }
            }). start();
        }
        try{
            Thread.sleep(2000);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println(count);
    }
}

代码分析
我们通过 try finally 模块,替代了之前的 synchronized 代码块,顺利的实现了多线程下的并发。

4. tryLock 方法

我们之前进行过介绍,Lock 接口包含了两种 tryLock 方法,一种无参数,一种带参数。

  • boolean tryLock():仅在调用时锁为空闲状态才获取该锁。如果锁可用,则获取锁,并立即返回值 true。如果锁不可用,则此方法将立即返回值 false;
  • boolean tryLock(long time, TimeUnit unit):如果锁在给定的等待时间内空闲,并且当前线程未被中断,则获取锁;

为了了解两种方法的使用,我们先来设置一个简单的使用场景。

场景设置

  • 创建两个线程,创建方式自选;
  • 两个线程同时执行代码逻辑;
  • 代码逻辑使用 boolean tryLock () 方法,如果获取到锁,执行打印当前线程名称,并沉睡 5000 毫秒;如果未获取锁,则打印 timeout,并处理异常信息;
  • 观察结果并进行分析;
  • 修改代码,使用 boolean tryLock (long time, TimeUnit unit) 方法,设置时间为 4000 毫秒;
  • 观察结果并进行分析;
  • 再次修改代码,使用 boolean tryLock (long time, TimeUnit unit) 方法,设置时间为 6000 毫秒;
  • 观察结果并进行分析。

实例:使用 boolean tryLock () 方法

public class DemoTest implements Runnable{
    private static Lock locks = new ReentrantLock();
    @Override
    public void run() {
        try {
            if(locks.tryLock()){ //尝试获取锁,获取成功则进入执行,不成功则执行finally模块
                System.out.println(Thread.currentThread().getName()+"-->");
                Thread.sleep(5000);
            }else{
                System.out.println(Thread.currentThread().getName()+" time out ");
            }
        } catch (InterruptedException e) {
             e.printStackTrace();
        }finally {
            try {
                locks.unlock();
            } catch (Exception e) {
                System.out.println(Thread.currentThread().getName() + "未获取到锁,释放锁抛出异常");
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        DemoTest test =new DemoTest();
        Thread t1 = new Thread(test);
        Thread t2 = new Thread(test);
        t1. start();
        t2. start();
        t1.join();
        t2.join();
        System.out.println("over");
    }
}

结果验证

Thread-1-->
Thread-0 time out 
Thread-0 未获取到锁,释放锁抛出异常
over

结果分析:从打印的结果来看, Thread-1 获取了锁权限,而 Thread-0 没有获取锁权限,这就是 tryLock,没有获取到锁资源则放弃执行,直接调用 finally。

实例:使用 boolean tryLock (4000 ms) 方法
将 if 判断进行修改如下:

if(locks.tryLock(4000,TimeUnit.MILLISECONDS)){ //尝试获取锁,获取成功则进入执行,不成功则执行finally模块
      System.out.println(Thread.currentThread().getName()+"-->");
      Thread.sleep(5000);
  }

结果验证

Thread-1-->
Thread-0 time out 
Thread-0 未获取到锁,释放锁抛出异常
over

结果分析:tryLock 方法,虽然等待 4000 毫秒,但是这段时间不足以等待 Thread-1 释放资源锁,所以还是超时。 我们换成 6000 毫秒试试。

实例:使用 boolean tryLock (6000 ms) 方法
将 if 判断进行修改如下:

if(locks.tryLock(6000,TimeUnit.MILLISECONDS)){ //尝试获取锁,获取成功则进入执行,不成功则执行finally模块
      System.out.println(Thread.currentThread().getName()+"-->");
      Thread.sleep(5000);
  }

结果验证

Thread-1-->
Thread-0-->
over

结果分析:tryLock 方法,等待 6000 毫秒,Thread-1 先进入执行,5000 毫秒后 Thread-0 进入执行,都能够有机会获取锁。

总结:以上就是 tryLock 方法的使用,可以指定最长的获取锁的时间,如果获取则执行,未获取则放弃执行。

5. 公平锁与非公平锁

分类:根据线程获取锁的抢占机制,锁可以分为公平锁和非公平锁。

公平锁:表示线程获取锁的顺序是按照线程请求锁的时间早晚来决定的,也就是最早请求锁的线程将最早获取到锁。

非公平锁:非公平锁则在运行时闯入,不遵循先到先执行的规则。

ReentrantLock:ReentrantLock 提供了公平和非公平锁的实现。

ReentrantLock 实例

//公平锁
ReentrantLock pairLock = new ReentrantLock(true);
//非公平锁
ReentrantLock pairLock1 = new ReentrantLock(false);
//如果构造函数不传递参数,则默认是非公平锁。
ReentrantLock pairLock2 = new ReentrantLock();

场景介绍:通过模拟一个场景假设,来了解公平锁与非公平锁。

  • 假设线程 A 已经持有了锁,这时候线程 B 请求该锁将会被挂起;
  • 当线程 A 释放锁后,假如当前有线程 C 也需要获取该锁,如果采用非公平锁方式,则根据线程调度策略,线程 B 和线程 C 两者之一可能获取锁,这时候不需要任何其他干涉;
  • 而如果使用公平锁则需要把 C 挂起,让 B 获取当前锁,因为 B 先到所以先执行。

Tips:在没有公平性需求的前提下尽量使用非公平锁,因为公平锁会带来性能开销。

6. lockInterruptibly 方法

lockInterruptibly () 方法:能够中断等待获取锁的线程。当两个线程同时通过 lock.lockInterruptibly () 获取某个锁时,假若此时线程 A 获取到了锁,而线程 B 只有等待,那么对线程 B 调用 threadB.interrupt () 方法能够中断线程 B 的等待过程。

场景设计

  • 创建两个线程,创建方式可自选实现;
  • 第一个线程先调用 start 方法,沉睡 20 毫秒后调用第二个线程的 start 方法,确保第一个线程先获取锁,第二个线程进入等待;
  • 最后调用第二个线程的 interrupt 方法,终止线程;
  • run 方法的逻辑为打印 0,1,2,3,4,每打印一个数字前,先沉睡 1000 毫秒;
  • 观察结果,看是否第二个线程被终止。

实例

public class DemoTest{
    private Lock lock = new ReentrantLock();

    public void doBussiness() {
        String name = Thread.currentThread().getName();
        try {
            System.out.println(name + " 开始获取锁");
            lock.lockInterruptibly(); //调用lockInterruptibly方法,表示可中断等待
            System.out.println(name + " 得到锁,开工干活");
            for (int i=0; i<5; i++) {
                Thread.sleep(1000);
                System.out.println(name + " : " + i);
            }
        } catch (InterruptedException e) {
            System.out.println(name + " 被中断");
        } finally {
            try {
                lock.unlock();
                System.out.println(name + " 释放锁");
            } catch (Exception e) {
                System.out.println(name + " : 没有得到锁的线程运行结束");
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        final DemoTest lockTest = new DemoTest();
        Thread t0 = new Thread(new Runnable() {
                    public void run() {
                        lockTest.doBussiness();
                    }});
        Thread t1 = new Thread(new Runnable() {
                    public void run() {
                        lockTest.doBussiness();
                    }});

        t0. start();
        Thread.sleep(20);
        t1. start();
        t1.interrupt();
    }
}

结果验证:可以看到,thread -1 被中断了。

Thread-0 开始获取锁
Thread-0 得到锁,开工干活
Thread-1 开始获取锁
Thread-1 被中断
Thread-1 : 没有得到锁的线程运行结束
Thread-0 : 0
Thread-0 : 1
Thread-0 : 2
Thread-0 : 3
Thread-0 : 4
Thread-0 释放锁

7. ReentrantLock 其他方法介绍

对 ReentrantLock 来说,方法很多样,如下介绍 ReentrantLock 其他的方法,有兴趣的同学可以自行的尝试使用。

  • getHoldCount():当前线程调用 lock () 方法的次数;
  • getQueueLength():当前正在等待获取 Lock 锁的线程的估计数;
  • getWaitQueueLength(Condition condition):当前正在等待状态的线程的估计数,需要传入 Condition 对象;
  • hasWaiters(Condition condition):查询是否有线程正在等待与 Lock 锁有关的 Condition 条件;
  • hasQueuedThread(Thread thread):查询指定的线程是否正在等待获取 Lock 锁;
  • hasQueuedThreads():查询是否有线程正在等待获取此锁定;
  • isFair():判断当前 Lock 锁是不是公平锁;
  • isHeldByCurrentThread():查询当前线程是否保持此锁定;
  • isLocked():查询此锁定是否由任意线程保持。

8. 小结

本节内容对 ReentrantLock 进行了比较详细的讲解,通篇内容皆为重点内容,需要同学们进行细致的掌握。核心内容即为 ReentrantLock 的使用,可以根据小节中的实例进行自行的编码和试验,更深刻的理解 ReentrantLock 的使用。

赞(0) 打赏
版权归原创作者所有,任何形式转载请联系我们:大白菜博客 » 二十二、ReentrantLock使用

评论 抢沙发

3 + 2 =
  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏