Java并发编程笔记之ReentrantLock源码分析-低调大师

Java并发编程笔记之ReentrantLock源码分析

2018-06-11 544

ReentrantLock是可重入的独占锁，同时只能有一个线程可以获取该锁，其他获取该锁的线程会被阻塞后放入该锁的AQS阻塞队列里面。

首先我们先看一下ReentrantLock的类图结构，如下图所示：

从类图可以知道，ReentrantLock最终还是使用AQS来实现，并且根据参数决定内部是公平锁还是非公平锁，默认是非公平锁。

首先我们先看ReentrantLock源码，看到其构造函数及其参数，这是决定内部是公平锁还是非公平锁，如下源码所示：

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

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

其中类Sync直接继承自AQS，它的子类NonfairSync和FairSync分别实现了获取锁的公平和非公平策略。

在这里AQS的状态值state代表线程获取该锁的可重入次数，默认情况下state的值为0，标示当前锁没有被任何线程持有，当一个线程第一次获取该锁的时候会尝试使用CAS设置state的值为1，如果CAS成功则当前线程获取了该锁，然后记录该锁的持有者为当前线程，

在该线程没有释放锁，第二次获取该锁后，状态值会加1，被设置为2，这就是可重入次数，在该线程释放该锁的时候，会尝试使用CAS让状态值减1，如果减1 后状态值为0 则当前线程释放该锁。

接下来我们看一下ReentrantLock是如何获取锁的，如下：

　　1.void lock() 当一个线程调用该方法，说明该线程希望获取该锁，如果锁当前没有被其它线程占用并且当前线程之前没有获取该锁，则当前线程会获取到该锁，然后设置当前锁的拥有者为当前线程，并设置 AQS 的状态值为 1 后直接返回。

如果当前线程之前已经获取过该锁，则这次只是简单的把 AQS 的状态值 status 加 1 后返回。如果该锁已经被其它线程持有，则调用该方法的线程会被放入 AQS 队列后阻塞挂起。源码如下：

　　public void lock() {
        sync.lock();
    }

如上面代码所示，ReentrantLock的lock()是委托给sync类，根据创建ReentrantLock的时候，构造函数选择sync的实现是NonfairSync或者FairSync，这里先看sync的子类NonfairSync的情况，也就是非公平锁的时候，源码如下：

final void lock() {
  //（1）CAS设置状态值
  if (compareAndSetState(0, 1))
      setExclusiveOwnerThread(Thread.currentThread());
  else
  //（2）调用AQS的acquire方法
      acquire(1);
}

如上面代码所示，代码（1）因为默认AQS的状态值为0，所以第一个调用Lock的线程会通过CAS设置状态值为1，CAS成功则代表当前线程获取到了锁，然后setExclusiveOwnerThread 设置了该锁持有者是当前线程。

如果这时候有其他线程调用lock方法企图获取该锁，执行代码（1）CAS会失败，然后会调用AQS的acquire方法，这里注意传递参数为1，接下来我们看AQS的acquire的核心代码，如下：

 　　public final void acquire(int arg) {
        //(3)调用ReentrantLock重写的tryAcquire方法
        if (!tryAcquire(arg) &&
            // tryAcquiref返回false会把当前线程放入AQS阻塞队列
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

之前说过 AQS 并没有提供可用的 tryAcquire 方法，tryAcquire 方法需要子类自己定制化，所以这里代码（3）会调用 ReentrantLock 重写的 tryAcquire 方法代码。

这里先看下非公平锁的源码代码如下：

protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
}

final boolean nonfairTryAcquire(int acquires) {
  final Thread current = Thread.currentThread();
  int c = getState();
  //（4）当前AQS状态值为0
  if (c == 0) {
      if (compareAndSetState(0, acquires)) {
          setExclusiveOwnerThread(current);
          return true;
      }
  }//(5)当前线程是该锁持有者
  else if (current == getExclusiveOwnerThread()) {
      int nextc = c + acquires;
      if (nextc < 0) // overflow
          throw new Error("Maximum lock count exceeded");
      setState(nextc);
      return true;
  }//(6)
  return false;
}

正如上面代码（4）会看当前锁的状态值是否为0，为0则说明当前该锁空闲，那么就尝试CAS获取该锁（尝试将 AQS 的状态值从 0 设置为 1），并设置当前锁的持有者为当前线程返回返回 true。

如果当前状态值不为0 则说明该锁已经被某个县城持有，所以代码（5）看当前线程是否是该锁的持有者，如果当前线程是该锁持有者，状态值增加1，然后返回true。

如果当前线程不是锁的持有者则返回 false, 然后会被放入 AQS 阻塞队列。

到目前为止，介绍完了非公平锁的实现代码，回过头看看非公平锁在这里是怎么体现的，首先非公平是说：先尝试获取锁的线程并不一定比后尝试获取锁的线程优先获取锁。

这里假设线程 A 调用 lock（）方法时候执行到了 nonfairTryAcquire 的代码（4）发现当前状态值不为 0，所以执行代码（5）发现当前线程不是线程持有者，则执行代码（6）返回 false，然后当前线程会被放入了 AQS 阻塞队列。

这时候线程 B 也调用了 lock() 方法执行到 nonfairTryAcquire 的代码（4）时候发现当前状态值为 0 了（假设占有该锁的其它线程释放了该锁）所以通过 CAS 设置获取到了该锁。而明明是线程 A 先请求获取的该锁那，这就是非公平锁的实现，

这里线程 B 在获取锁前并没有看当前 AQS 队列里面是否有比自己请求该锁更早的线程，而是使用了抢夺策略。

好了，知道非公平锁的实现了，那么我们接下来看一下公平锁是如何实现的呢？

公平锁的实现只需要看FairSync重写的tryAcquire方法，源码如下：

　　protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            //（7）当前AQS状态值为0
            if (c == 0) {
             //（8）公平性策略
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            //（9）当前线程是该锁持有者
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");

                setState(nextc);
                return true;
            }//(10)
            return false;
        }
    }

如上代码公平性的tryAcquire策略与非公平锁的类似，不同在于代码（8）处设置CAS前添加了hasQueuedPredecessors 方法，该方法是实现公平性的核心代码，源代码如下：

　　public final boolean hasQueuedPredecessors() {

        Node t = tail; // Read fields in reverse initialization order
        Node h = head;
        Node s;
        return h != t &&((s = h.next) == null || s.thread != Thread.currentThread());
    }

如上代码所示，如果当前线程节点有前驱节点则返回true，否则如果当前AQS队列为空或者当前线程节点是AQS的第一个节点则返回false。

其中如果h == t 则说明当前队列为空则直接返回false，如果h != t 并且 (s = h.next) ==null 说明有一个元素将要作为AQS的第一个节点入队列，那么返回true，如果h != t 并且 (s = h.next) !=null 并且 s.thread != Thread.currentThread() 则说明队列里面的第一个元素不是当前线程则返回 true。

　　2.void lockInterruptibly() 与 lock() 方法类似，不同在于该方法对中断响应，就是当前线程在调用该方式时候，如果其它线程调用了当前线程线程的 interrupt（）方法，当前线程会抛出 InterruptedException 异常然后返回，源代码如下：

public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
}

public final void acquireInterruptibly(int arg)throws InterruptedException {
   //当前线程被中断则直接抛出异常
   if (Thread.interrupted())
       throw new InterruptedException();
   //尝试获取资源
   if (!tryAcquire(arg))
       //调用AQS可被状态的方法
       doAcquireInterruptibly(arg);
}

　　3.boolean tryLock() 尝试获取锁，如果当前该锁没有被其它线程持有则当前线程获取该锁并返回 true, 否者返回 false，注意该方法不会引起当前线程阻塞。源码如下所示：

public boolean tryLock() {
   return sync.nonfairTryAcquire(1);
}

final boolean nonfairTryAcquire(int acquires) {
  final Thread current = Thread.currentThread();
  int c = getState();
  if (c == 0) {
      if (compareAndSetState(0, acquires)) {
          setExclusiveOwnerThread(current);
          return true;
      }
  }
  else if (current == getExclusiveOwnerThread()) {
      int nextc = c + acquires;
      if (nextc < 0) // overflow
          throw new Error("Maximum lock count exceeded");
      setState(nextc);
      return true;
  }
  return false;
}

如上代码与非公平锁的 tryAcquire() 方法类似，所以 tryLock() 使用的是非公平策略。

　　4.boolean tryLock(long timeout, TimeUnit unit) 尝试获取锁与 tryLock（）不同在于设置了超时时间，如果超时没有获取该锁则返回 false。源代码如下：

 public boolean tryLock(long timeout, TimeUnit unit)throws InterruptedException {
        //调用AQS的tryAcquireNanos方法。
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }

接下来我们要看一下，ReentrantLock是如何释放锁的。

　　1.void unlock() 尝试释放锁，如果当前线程持有该锁，调用该方法会让该线程对该线程持有的 AQS 状态值减一，如果减去 1 后当前状态值为 0 则当前线程会释放对该锁的持有，否者仅仅减一而已。

如果当前线程没有持有该锁调用了该方法则会抛出 IllegalMonitorStateException 异常，源代码如下：

　　public void unlock() {
        sync.release(1);
    }

   protected final boolean tryRelease(int releases) {
      //(11)如果不是锁持有者调用UNlock则抛出异常。
       int c = getState() - releases;
       if (Thread.currentThread() != getExclusiveOwnerThread())
           throw new IllegalMonitorStateException();
       boolean free = false;
      //(12)如果当前可重入次数为0，则清空锁持有线程
       if (c == 0) {
           free = true;
           setExclusiveOwnerThread(null);
       }
       //(13)设置可重入次数为原始值-1
       setState(c);
       return free;
   }

如上代码所示（11）如果当前线程不是该锁持有者则直接抛异常，否则，看状态值剩余值是否为0，为0 则说明当前线程要释放对该锁的持有权，则执行代码（12）把当前锁持有者设置为null。

如果剩余值不为0，则仅仅让当前线程对该锁的可重入次数减1。

到目前基本了解了ReentrantLock的原理，那么接下来我们是否可以用ReentrantLock来实现一个简单的线程安全的list呢？

例子如下：

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

/**
 * Created by cong on 2018/6/12.
 */
public class ReentrantLockList {

    //线程不安全的list
    private ArrayList<String> array = new ArrayList<String>();
    //独占锁
    private volatile ReentrantLock lock = new ReentrantLock();

    //添加元素
    public void add(String e) {

        lock.lock();
        try {
            array.add(e);
        } finally {
            lock.unlock();
        }
    }
    //删元素
    public void remove(String e) {

        lock.lock();
        try {
            array.remove(e);
        } finally {
            lock.unlock();

        }
    }

    //获取数据
    public String get(int index) {

        lock.lock();
        try {
            return array.get(index);
        } finally {
            lock.unlock();

        }
    }
    
}

如上代码通过在操作 array 元素前进行加锁保证同时只有一个线程可以对 array 数组进行修改，但是同时也只能有一个线程对 array 元素进行访问。

最后几个图加深前面所学的内容，如下图所示：

如上图，假如线程 Thread1,Thread2,Thread3 同时尝试获取独占锁 ReentrantLock，假设 Thread1 获取到了，则 Thread2 和 Thread3 就会被转换为 Node 节点后放入 ReentrantLock 对应的 AQS 阻塞队列后阻塞挂起。

如上图，假设 Thread1 获取锁后调用了对应的锁创建的条件变量 1，那么 Thread1 就会释放获取到的锁，然后当前线程就会被转换为 Node 节点后插入到条件变量 1 的条件队列，由于 Thread1 释放了锁，

所以阻塞到 AQS 队列里面 Thread2 和 Thread3 就有机会获取到该锁，假如使用的公平策略，那么这时候 Thread2 会获取到该锁，会从 AQS 队列里面移除 Thread2 对应的 Node 节点。

微信关注我们

原文链接：https://yq.aliyun.com/articles/601724

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

ameba-alios things RTL8710BN 编译下载运行

问题汇总： rel_1.3.0 编译运行hardfault问题一、下载/安装 Visual Studio Code https://code.visualstudio.com/ 安装 AliOS Studio 插件安装 C/C++ 插件，搜索c/c++ 安装 alios-studio 插件，搜索alios-studio 二、请使用Windows7 64bit，使用Install_Win脚本可以直接使用我们准备好的一键安装包：http://p28phe5s5.bkt.clouddn.com/setup_windows.zip 全部默认下一步就好不要修改该路径，真的会出错，有洁癖，自行研究吧如果出现如下问题：更新下：（1）到C:\Python27\Scripts，执行：pip install wheel （2）安装setuptools，下载set

2018-06-11

703

Java CompletableFuture（1）

Java CompletableFuture（1） private Long longTimeWork() { try { //模拟耗时操作，特意阻塞5秒。 TimeUnit.SECONDS.sleep(5); } catch (InterruptedException e) { e.printStackTrace(); } return System.currentTimeMillis(); } @Override protected void onCreate(@Nullable Bundle savedInstanceState) { super.onCreate(savedInstanceState); System.out.println("时间1:" + System.currentTimeMillis()); CompletableFuture<Long> future = CompletableFuture.supplyAsync(() -> longTimeWork()); System.out.println("时间2:" + System.cur...

2018-06-11

568

发表评论

资源下载

更多资源

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

WebStorm

WebStorm 是jetbrains公司旗下一款JavaScript 开发工具。目前已经被广大中国JS开发者誉为“Web前端开发神器”、“最强大的HTML5编辑器”、“最智能的JavaScript IDE”等。与IntelliJ IDEA同源，继承了IntelliJ IDEA强大的JS部分的功能。