juc：ReentrantLock

参考：

这篇 ReentrantLock 看不懂，加我我给你发红包

万字超强图文讲解AQS以及ReentrantLock应用（建议收藏）

基本概念

synchronized的局限性

synchronized是java内置的关键字，它提供了一种独占的加锁方式。synchronized的获取和释放锁由jvm实现，用户不需要显示的释放锁，非常方便，然而synchronized也有一定的局限性，例如：

当线程尝试获取锁的时候，如果获取不到锁会一直阻塞，这个阻塞的过程，用户无法控制

如果获取锁的线程进入休眠或者阻塞，除非当前线程异常，否则其他线程尝试获取锁必须一直等待

JDK1.5之后发布，加入了Doug Lea实现的java.util.concurrent包。包内提供了Lock类，用来提供更多扩展的加锁功能。Lock弥补了synchronized的局限，提供了更加细粒度的加锁功能。

 

ReentrantLock是Lock的默认实现，在聊ReentranLock之前，我们需要先弄清楚一些概念：

可重入锁：可重入锁是指同一个线程可以多次获得同一把锁；ReentrantLock和关键字Synchronized都是可重入锁
可中断锁：可中断锁时只线程在获取锁的过程中，是否可以相应线程中断操作。synchronized是不可中断的，ReentrantLock是可中断的
公平锁和非公平锁：公平锁是指多个线程尝试获取同一把锁的时候，获取锁的顺序按照线程到达的先后顺序获取，而不是随机插队的方式获取。synchronized是非公平锁，而ReentrantLock是两种都可以实现，不过默认是非公平锁

 

ReentrantLock，可重入锁，是一种递归无阻塞的同步机制。

它可以等同于synchronized的使用，但是ReentrantLock提供了比synchronized更强大、灵活的锁机制，可以减少死锁发生的概率。

API介绍如下：

一个可重入的互斥锁定 Lock，它具有与使用 synchronized 方法和语句所访问的隐式监视器锁定相同的一些基本行为和语义，但功能更强大。

ReentrantLock 将由最近成功获得锁定，并且还没有释放该锁定的线程所拥有。

当锁定没有被另一个线程所拥有时，调用 lock 的线程将成功获取该锁定并返回。

如果当前线程已经拥有该锁定，此方法将立即返回。可以使用 isHeldByCurrentThread() 和 getHoldCount() 方法来检查此情况是否发生。

ReentrantLock还提供了公平锁和非公平锁的选择，构造方法接受一个可选的公平参数（默认非公平锁），当设置为true时，表示公平锁，否则为非公平锁。

公平锁与非公平锁的区别在于公平锁的锁获取是有顺序的。但是公平锁的效率往往没有非公平锁的效率高，在许多线程访问的情况下，公平锁表现出较低的吞吐

ReentrantLock 的基本使用

我们使用3个线程来对一个共享变量++操作，先使用synchronized实现，然后使用ReentrantLock实现。

synchronized方式：

package threads.ReentrantLock.test1;

public class Demo2 {
    private static int num = 0;
    private static synchronized void add(){
        num++;
    }
    public static class T extends Thread{
        @Override
        public void run(){
            for (int i=0 ; i<10000 ; i++){
                Demo2.add();
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        T t1 = new T();
        T t2 = new T();
        T t3 = new T();

        t1.start();
        t2.start();
        t3.start();

        t1.join();
        t2.join();
        t3.join();

        System.out.println(Demo2.num);
    }

}
View Code

ReentrantLock方式：

package threads.ReentrantLock.test1;
import java.util.concurrent.locks.ReentrantLock;
import javax.sound.midi.Soundbank;
import threads.executor.Main;

public class Demo3 {
    private static int num = 0;
    private static ReentrantLock lock = new ReentrantLock();
    private static void add(){
        lock.lock();
        try {
            num++;
        }finally{
            lock.unlock();
        }
    }
    public static class T extends Thread{
        @Override
        public void run(){
            for(int i=0;i<10000;i++){
                Demo3.add();
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        T t1 = new T();
        T t2 = new T();
        T t3 = new T();

        t1.start();
        t2.start();
        t3.start();

        t1.join();
        t2.join();
        t3.join();
        System.out.println(Demo3.num);
    }
}
View Code

ReentrantLock的使用过程：

  • 创建锁：ReentrantLock lock = new ReentrantLock();
  • 获取锁：lock.lock()
  • 释放锁：lock.unlock();

对比上面的代码，与关键字synchronized相比，ReentrantLock锁有明显的操作过程，开发人员必须手动的指定何时加锁，何时释放锁，

正是因为这样手动控制，ReentrantLock对逻辑控制的灵活度要远远胜于关键字synchronized，

上面代码需要注意lock.unlock()一定要放在finally中，否则，若程序出现了异常，锁没有释放，那么其他线程就再也没有机会获取这个锁了。

ReentrantLock实现公平锁

在大多数情况下，锁的申请都是非公平的，也就是说，线程1首先请求锁A，接着线程2也请求了锁A。

那么当锁A可用时，是线程1可获得锁还是线程2可获得锁呢？这是不一定的，系统只是会从这个锁的等待队列中随机挑选一个，因此不能保证其公平性。

这就好比买票不排队，大家都围在售票窗口前，售票员忙的焦头烂额，也顾及不上谁先谁后，随便找个人出票就完事了，最终导致的结果是，有些人可能一直买不到票。

而公平锁，则不是这样，它会按照到达的先后顺序获得资源。

公平锁的一大特点是：它不会产生饥饿现象，只要你排队，最终还是可以等到资源的；

synchronized关键字默认是有jvm内部实现控制的，是非公平锁。而ReentrantLock运行开发者自己设置锁的公平性。

看一下jdk中ReentrantLock的源码，2个构造方法：

    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

    public ReentrantLock() {
        sync = new NonfairSync();
    }
View Code

默认构造方法创建的是非公平锁。

第2个构造方法，有个fair参数，当fair为true的时候创建的是公平锁，公平锁看起来很不错，不过要实现公平锁，系统内部肯定需要维护一个有序队列，

因此公平锁的实现成本比较高，性能相对于非公平锁来说相对低一些。因此，在默认情况下，锁是非公平的，如果没有特别要求，则不建议使用公平锁。

公平锁和非公平锁在程序调度上是很不一样，来一个公平锁示例看一下：

package threads.ReentrantLock.test1;

import java.util.concurrent.locks.ReentrantLock;

public class Demo5 {
    private static int num = 0;
    private static ReentrantLock fairLock = new ReentrantLock(true);
    private static ReentrantLock unFairLock = new ReentrantLock(false);

    public static class T extends Thread{
        public T(String name){
            super(name);
        }

        @Override
        public void run(){
            for (int i =0; i<5 ;i++){
                fairLock.lock();
                try {
                    System.out.println(this.getName() + " get lock");
                    sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally{
                    fairLock.unlock();
                }
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        T t1 = new T("t1");
        T t2 = new T("t2");
        T t3 = new T("t3");

        t1.start();
        t2.start();
        t3.start();

        t1.join();
        t2.join();
        t3.join();
    }
}

t1 get lock
t2 get lock
t3 get lock
t1 get lock
t2 get lock
t3 get lock
t1 get lock
t2 get lock
t3 get lock
t1 get lock
t2 get lock
t3 get lock
t1 get lock
t2 get lock
t3 get lock
View Code

 

获取锁

我们一般都是这么使用ReentrantLock获取锁的：
//非公平锁

ReentrantLock lock = new ReentrantLock();
lock.lock();

lock方法：
    public void lock() {
        sync.lock();
    }

Sync为ReentrantLock里面的一个内部类，它继承AQS（AbstractQueuedSynchronizer），

它有两个子类：公平锁FairSync和非公平锁NonfairSync。

ReentrantLock里面大部分的功能都是委托给Sync来实现的，同时Sync内部定义了lock()抽象方法由其子类去实现，

默认实现了nonfairTryAcquire(int acquires)方法，可以看出它是非公平锁的默认实现方式。

下面我们看非公平锁的lock()方法：

ReentrantLock与synchronized的区别

前面提到ReentrantLock提供了比synchronized更加灵活和强大的锁机制，那么它的灵活和强大之处在哪里呢？

他们之间又有什么相异之处呢？ 首先他们肯定具有相同的功能和内存语义。

与synchronized相比，ReentrantLock提供了更多，更加全面的功能，具备更强的扩展性。例如：时间锁等候，可中断锁等候，锁投票。

ReentrantLock还提供了条件Condition，对线程的等待、唤醒操作更加详细和灵活，所以在多个条件变量和高度竞争锁的地方，ReentrantLock更加适合（以后会阐述Condition）。

ReentrantLock提供了可轮询的锁请求。它会尝试着去获取锁，如果成功则继续，否则可以等到下次运行时处理，

而synchronized则一旦进入锁请求要么成功要么阻塞，所以相比synchronized而言，ReentrantLock会不容易产生死锁些。

ReentrantLock支持更加灵活的同步代码块，但是使用synchronized时，只能在同一个synchronized块结构中获取和释放。

注：ReentrantLock的锁释放一定要在finally中处理，否则可能会产生严重的后果。

ReentrantLock支持中断处理，且性能较synchronized会好些。

ReentrantLock 是一把可重入锁和互斥锁


/**
* Fair version of tryAcquire.  Don't grant access unless
* recursive call or no waiters or is first.
*/
protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();//获取当前锁状态
    if (c == 0) { //状态为0，即为无锁状态
        if (!hasQueuedPredecessors() &&
            compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }//如果读取的同步状态是1，说明已经线程获取到了锁，那么就先判断当前线程是不是获取锁的线程，如果是的话，记录一下获取锁的次数 + 1，
       //也就是说，只有同步状态为 0 的时候是无锁状态。如果当前线程不是获取锁的线程，直接返回 false。
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

//找出当前线程在锁等待的队列中是否还有更靠前的线程
public final boolean hasQueuedPredecessors() {
    // The correctness of this depends on head being initialized
    // before tail and on head.next being accurate if the current
    // thread is first in queue.
    Node t = tail; // Read fields in reverse initialization order
    Node h = head;
    Node s;
    //队列头不等于尾， 
    //将头的下一个节点赋值给s s为null直接返回true，s不等于null才需要判断后面的逻辑
      //s对应的线程不等于当前线程则返回true 即线程前面还有等待的线程
    return h != t && 
        ((s = h.next) == null || s.thread != Thread.currentThread());
}
View Code

ReentrantLock是可重入锁

来验证一下ReentrantLock是可重入锁，实例代码：

package threads.ReentrantLock.test1;
import java.util.concurrent.locks.ReentrantLock;

public class Demo4 {
    private static int num = 0;
    private static ReentrantLock lock = new ReentrantLock();

    private static void add(){
        lock.lock();
        lock.lock();
        try {
            num++;
        }finally{
            lock.unlock();
            lock.unlock();
        }
    }
    public static class T extends Thread{
        @Override
        public void run(){
            for (int i=0 ; i<10000 ; i++){
                Demo4.add();
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        T t1 = new T();
        T t2 = new T();
        T t3 = new T();

        t1.start();
        t2.start();
        t3.start();

        t1.join();
        t2.join();
        t3.join();

        System.out.println(Demo4.num);
    }

}
View Code 

上面代码中add()方法中，当一个线程进入的时候，会执行2次获取锁的操作，运行程序可以正常结束，并输出和期望值一样的30000，

假如ReentrantLock是不可重入的锁，那么同一个线程第2次获取锁的时候由于前面的锁还未释放而导致死锁，程序是无法正常结束的。

ReentrantLock命名也挺好的Re entrant Lock，和其名字一样，可重入锁。

代码中还有几点需要注意：

lock()方法和unlock()方法需要成对出现，锁了几次，也要释放几次，否则后面的线程无法获取锁了；可以将add中的unlock删除一个事实，上面代码运行将无法结束

unlock()方法放在finally中执行，保证不管程序是否有异常，锁必定会释放

ReentrantLock获取锁的过程是可中断的

对于synchronized关键字，如果一个线程在等待获取锁，最终只有2种结果：

要么获取到锁然后继续后面的操作

要么一直等待，直到其他线程释放锁为止

而ReentrantLock提供了另外一种可能，就是在等的获取锁的过程中（发起获取锁请求到还未获取到锁这段时间内）是可以被中断的，

也就是说在等待锁的过程中，程序可以根据需要取消获取锁的请求。有些使用这个操作是非常有必要的。

比如：你和好朋友越好一起去打球，如果你等了半小时朋友还没到，突然你接到一个电话，朋友由于突发状况，不能来了，那么你一定达到回府。

中断操作正是提供了一套类似的机制，如果一个线程正在等待获取锁，那么它依然可以收到一个通知，被告知无需等待，可以停止工作了。 

示例代码：

package threads.ReentrantLock.test1;

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


public class Demo6 {
    private static ReentrantLock lock1 = new ReentrantLock(false);
    private static ReentrantLock lock2 = new ReentrantLock(false);
    public static class T extends Thread{
        int lock;
        public T(String name , int lock){
            super(name);
            this.lock = lock;
        }
        @Override
        public void run(){
            try {
                if(this.lock == 1){
                    lock1.lockInterruptibly();//t1 获取到锁lock1
                    TimeUnit.SECONDS.sleep(1);
                    lock2.lockInterruptibly(); //t1想去获取锁lock2
                }else {
                    lock2.lockInterruptibly();//t2 获取到锁lock2
                    TimeUnit.SECONDS.sleep(1);
                    lock1.lockInterruptibly(); //t2想获取到锁lock1
                }
            }catch (InterruptedException ex){
                System.out.println("interupt flag: "+this.isInterrupted());
                ex.printStackTrace();
            }finally{
                if(lock1.isHeldByCurrentThread()){//判断当前线程是否获取到锁lock1
                    lock1.unlock();
                }
                if(lock2.isHeldByCurrentThread()){//判断当前线程是否获取到锁lock2
                    lock2.unlock();
                }
            }
        }
    }
    public static void main(String[] args) {
        T t1 = new T("t1",1);
        T t2 = new T("t2", 2);
        t1.start();
        t2.start();
    }
}
View Code

先运行一下上面代码，发现程序无法结束，使用jstack查看线程堆栈信息，发现2个线程死锁了。

lock1被线程t1占用，lock2倍线程t2占用，线程t1在等待获取lock2，线程t2在等待获取lock1，都在相互等待获取对方持有的锁，

最终产生了死锁，如果是在synchronized关键字情况下发生了死锁现象，程序是无法结束的。

我们队上面代码改造一下，线程t2一直无法获取到lock1，那么等待5秒之后，我们中断获取锁的操作。主要修改一下main方法，如下：

    public static void main(String[] args) throws InterruptedException {
        T t1 = new T("t1",1);
        T t2 = new T("t2", 2);
        t1.start();
        t2.start();

        TimeUnit.SECONDS.sleep(5);
        t2.interrupt();
    }
View Code

新增了2行代码 TimeUnit.SECONDS.sleep(5);t2.interrupt();，程序可以结束了，运行结果：

从上面信息中可以看出，代码的31行触发了异常，中断标志输出：false

t2在31行一直获取不到lock1的锁，主线程中等待了5秒之后，t2线程调用了 interrupt()方法，将线程的中断标志置为true，此时31行会触发 InterruptedException异常，

然后线程t2可以继续向下执行，释放了lock2的锁，然后线程t1可以正常获取锁，程序得以继续进行。线程发送中断信号触发InterruptedException异常之后，中断标志将被清空。

关于获取锁的过程中被中断，注意几点:

  • ReentrankLock中必须使用实例方法 lockInterruptibly()获取锁时，在线程调用interrupt()方法之后，才会引发 InterruptedException异常
  • 线程调用interrupt()之后，线程的中断标志会被置为true
  • 触发InterruptedException异常之后，线程的中断标志有会被清空，即置为false
  • 所以当线程调用interrupt()引发InterruptedException异常，中断标志的变化是:false->true->false

 

ReentrantLock锁申请等待限时

申请锁等待限时是什么意思？一般情况下，获取锁的时间我们是不知道的，synchronized关键字获取锁的过程中，只能等待其他线程把锁释放之后才能够有机会获取到所。

所以获取锁的时间有长有短。如果获取锁的时间能够设置超时时间，那就非常好了。

 

ReentrantLock刚好提供了这样功能，给我们提供了获取锁限时等待的方法 tryLock()，可以选择传入时间参数，表示等待指定的时间，

无参则表示立即返回锁申请的结果：true表示获取锁成功，false表示获取锁失败。

tryLock无参方法

返回boolean类型的值，此方法会立即返回，结果表示获取锁是否成功，示例：

package threads.ReentrantLock.test1;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
import cn.hutool.core.date.DateTime;

public class Demo8 {
    private static ReentrantLock lock1 = new ReentrantLock(false);

    public static class T extends Thread{
        public T(String name){
            super(name);
        }

        @Override
        public void run(){
            try {
                System.out.println(DateTime.now() + ":" + this.getName() + "start get lock");
                if(lock1.tryLock()){
                    System.out.println(DateTime.now()+ ":" + this.getName() + "already get lock");
                    TimeUnit.SECONDS.sleep(5);
                }else {
                    System.out.println(DateTime.now()+ ":" +this.getName() + "can not get lock");
                }
            }catch (InterruptedException ex){
                ex.printStackTrace();
            }finally{
                if(lock1.isHeldByCurrentThread()){
                    lock1.unlock();
                }
            }
        }
    }
    public static void main(String[] args) {
        T t1= new T("t1");
        T t2= new T("t2");

        t1.start();
        t2.start();
    }

}
View Code

代码中获取锁成功之后，休眠5秒，会导致另外一个线程获取锁失败，运行代码，输出：

2021-06-10 13:43:20:t1start get lock
2021-06-10 13:43:20:t2start get lock
2021-06-10 13:43:20:t1already get lock
2021-06-10 13:43:20:t2can not get lock

可以看到t2获取成功，t1获取失败了，tryLock()是立即响应的，中间不会有阻塞。

可以明确设置获取锁的超时时间，该方法签名：

    public boolean tryLock(long timeout, TimeUnit unit)
            throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));

该方法在指定的时间内不管是否可以获取锁，都会返回结果，返回true，表示获取锁成功，返回false表示获取失败。

此方法由2个参数，第一个参数是时间类型，是一个枚举，可以表示时、分、秒、毫秒等待，使用比较方便，第1个参数表示在时间类型上的时间长短。

此方法在执行的过程中，如果调用了线程的中断interrupt()方法，会触发InterruptedException异常。

示例：

package threads.ReentrantLock.test1;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
import cn.hutool.core.date.DateTime;

public class Demo8 {
    private static ReentrantLock lock1 = new ReentrantLock(false);

    public static class T extends Thread{
        public T(String name){
            super(name);
        }

        @Override
        public void run(){
            try {
                System.out.println(DateTime.now() + ":" + this.getName() + " start get lock");
                if(lock1.tryLock(3,TimeUnit.SECONDS)){
                    System.out.println(DateTime.now()+ ":" + this.getName() + " already get lock");
                    TimeUnit.SECONDS.sleep(5);
                }else {
                    System.out.println(DateTime.now()+ ":" +this.getName() + " can not get lock");
                }
            }catch (InterruptedException ex){
                ex.printStackTrace();
            }finally{
                if(lock1.isHeldByCurrentThread()){
                    lock1.unlock();
                }
            }
        }
    }
    public static void main(String[] args) {
        T t1= new T("t1");
        T t2= new T("t2");

        t1.start();
        t2.start();
    }

}

2021-06-10 13:49:13:t2 start get lock
2021-06-10 13:49:13:t1 start get lock
2021-06-10 13:49:13:t2 already get lock
2021-06-10 13:49:16:t1 can not get lock
View Code

程序中调用了ReentrantLock的实例方法 tryLock(3,TimeUnit.SECONDS)，表示获取锁的超时时间是3秒，3秒后不管是否能否获取锁，该方法都会有返回值，

获取到锁之后，内部休眠了5秒，会导致另外一个线程获取锁失败。

输出结果中分析，t2获取到锁了，然后休眠了5秒，t1获取锁失败，t1打印了2条信息，时间相差3秒左右。

关于tryLock()方法和tryLock(long timeout, TimeUnit unit)方法，说明一下：

  1. 都会返回boolean值，结果表示获取锁是否成功
  2. tryLock()方法，不管是否获取成功，都会立即返回；而有参的tryLock方法会尝试在指定的时间内去获取锁，中间会阻塞的现象，在指定的时间之后会不管是否能够获取锁都会返回结果
  3. tryLock()方法不会响应线程的中断方法；而有参的tryLock方法会响应线程的中断方法，而出发 InterruptedException异常，这个从2个方法的声明上可以可以看出来

ReentrantLock其他常用的方法

isHeldByCurrentThread：实例方法，判断当前线程是否持有ReentrantLock的锁，上面代码中有使用过。

获取锁的4种方法对比

获取锁的方法是否立即响应(不会阻塞)是否响应中断
lock() × ×
lockInterruptibly() × √
tryLock() √ ×
tryLock(long timeout, TimeUnit unit) × √

总结

  1. ReentrantLock可以实现公平锁和非公平锁
  2. ReentrantLock默认实现的是非公平锁
  3. ReentrantLock的获取锁和释放锁必须成对出现，锁了几次，也要释放几次
  4. 释放锁的操作必须放在finally中执行
  5. lockInterruptibly()实例方法可以相应线程的中断方法，调用线程的interrupt()方法时，lockInterruptibly()方法会触发 InterruptedException异常
  6. 关于 InterruptedException异常说一下，看到方法声明上带有 throwsInterruptedException，表示该方法可以相应线程中断，调用线程的interrupt()方法时，这些方法会触发 InterruptedException异常，触发
  7. InterruptedException时，线程的中断中断状态会被清除。所以如果程序由于调用 interrupt()方法而触发 InterruptedException异常，线程的标志由默认的false变为ture，然后又变为false
  8. 实例方法tryLock()获会尝试获取锁，会立即返回，返回值表示是否获取成功
  9. 实例方法tryLock(long timeout, TimeUnit unit)会在指定的时间内尝试获取锁，指定的时间内是否能够获取锁，都会返回，返回值表示是否获取锁成功，该方法会响应线程的中断

 

参考

ReentrantLock源码分析

ReentrantLock(重入锁)功能详解和应用演示

Synchronized 与 ReentrantLock 的区别！

这篇 ReentrantLock 看不懂，加我我给你发红包

死磕Java并发】—–J.U.C之重入锁：ReentrantLock、

java高并发系列 - 第12天JUC:ReentrantLock重入锁

 

 

 

posted @ 2019-12-15 15:14  弱水三千12138  阅读(155)  评论(0)    收藏  举报