ReentrantLock 锁分析 1

- 日理万妓 2022-12-06 12:49 174阅读 0赞

在阅读本文应对AQS有一定基础了解，可参阅博主其他博文

[AQS分析1-基于AQS自定义锁分析][AQS_1-_AQS]

### 文章目录 ###

*  前言
 *  一、ReentrantLock基础用法
 *  二、类结构
 *  公平锁
 *   *  加锁流程
     *  解锁流程
 *  非公平锁
 *   *  加锁流程
     *  解锁流程
 *  参考

--------------------

# 前言 #

`ReentrantLock`是一个基于`AQS`的可`重入锁`，实现了`公平锁`,`非公平`，`超时`,`条件变量`等

# 一、ReentrantLock基础用法 #

public class Main {
        
        public static void main(String[] args) {
        
            /**
             * 构造函数true 表示公平锁
             */
            ReentrantLock reentrantLock = new ReentrantLock(true);
            //粗略的让子线程执行完成
            int i = 0;
            while (++i < 1000) {
        
                Thread thread = new Thread(() ->
                {
        
                    reentrantLock.lock();
                    System.out.println(Thread.currentThread() + " 成功上锁");
    
                    try {
        
                        TimeUnit.MILLISECONDS.sleep(20);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread() + " 成功解锁");
                    reentrantLock.unlock();
                }, "线程[" + i + "]");
    
                thread.start();
            }
            try {
        
                TimeUnit.HOURS.sleep(1);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
        }
    }

输出：

Thread[线程[1],5,main] 成功上锁
    Thread[线程[1],5,main] 成功解锁
    Thread[线程[2],5,main] 成功上锁
    Thread[线程[2],5,main] 成功解锁
    Thread[线程[3],5,main] 成功上锁
    Thread[线程[3],5,main] 成功解锁
    Thread[线程[4],5,main] 成功上锁
    Thread[线程[4],5,main] 成功解锁
    Thread[线程[5],5,main] 成功上锁
    Thread[线程[5],5,main] 成功解锁
    Thread[线程[6],5,main] 成功上锁

# 二、类结构 #

--------------------

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

核心组件类继承图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70_pic_center]  
我们继续查看对应属性方法等：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70_pic_center 1]

# 公平锁 #

## 加锁流程 ##

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

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

//FairSync.java
     final void lock() {
        
         acquire(1);
    }

`acquire` 函数在博主的 [AQS分析1-基于AQS自定义锁分析][AQS_1-_AQS]有做过分析，此文不做阐述。

//AbstractQueuedSynchronizer.java
     public final void acquire(int arg) {
        
            if (!tryAcquire(arg) &&
                acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
                selfInterrupt();
        }

公平锁加锁核心实现

protected final boolean tryAcquire(int acquires) {
        
                final Thread current = Thread.currentThread();
                int c = getState();
                //状态等于0证明 ，有人释放了锁，或者根本没人竞争锁
                if (c == 0) {
        
                	//hasQueuedPredecessors 判断有没有前驱节点
                	//如果没有就设置状态，并同时设置持有线程
                    if (!hasQueuedPredecessors() &&
                        compareAndSetState(0, acquires)) {
        
                        setExclusiveOwnerThread(current);
                        return true;
                    }
                }else if (current == getExclusiveOwnerThread()) {
        
                	//当前线程已经获得了锁。那么让其重入操作即可。重入锁特性
                    int nextc = c + acquires;
     	               if (nextc < 0)
                        throw new Error("Maximum lock count exceeded");
                    setState(nextc);
                    return true;
                }
                return false;
            }
        }

`hasQueuedPredecessors`函数讲解：  
`hasQueuedPredecessors`来自`AQS`类，用于获取当前是否存在前驱节点，如果有证明在之前还有别的线程正在等候锁。

public final boolean hasQueuedPredecessors() {
        
            
            //一定要先赋值tail给t 在赋值 h = head。
            //因为初始化的时候 我们先初始化head在初始化tail,
            //所以先获取tail保证 保证head已经被初始化
            //如果先获取head在获取tail 有可能 head!=null taill==null
    
            Node t = tail;
            Node h = head;
            Node s;
            //h==t  （1）初始化状态才有可能 （2）或者没初始化的时候都为null时 （3) 已经没有等候的线程了(但是有可能锁还在被别的线程使用，只是没有其他线程竞争)
            // (s = h.next) == null  头结点没有下一个节点
            // s.thread != Thread.currentThread() 下个等候唤醒的节点线程不是当前线程
            return h != t &&
                ((s = h.next) == null || s.thread != Thread.currentThread());
        }

我们来看下判断几个条件：

**(1)什么时候`h==t`成立？**

1.  未初始化  
    头尾节点都是`null`。这种情况比较容易理解。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70_pic_center 2]
2.  初始化AQS过程  
    初始化状态时线程还没进入休眠，此时`AQS`正在构造一个头尾相同的`Node`,然后再将某个线程放入队列尾部。但是并没有其他线程休眠。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70_pic_center 3]
3.  此时有两种情况，第一个情况：某个持有线程锁的还在运行，但是已经没有其他线程在去竞争锁。第二个情况：没有持有锁线程，残留头结点和尾结点。（具体例子：此时有三个线程在等候队列中，在某一时刻三个线程全部依次得到锁运行完成。）

> AQS 线程获得锁，会把自己节点设置头节点，但是不会控制尾结点引用。

所以当 `h==t`时表示没线程去等候锁

**(2) (s = h.next) == null**

发生`h != t &&((s = h.next) == null`的情况：  
`CLH`队列在初始化时要创建一个线程节点，刚构造`Head`节点，但是没有构造尾结点的时候，此时  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70_pic_center 4]

我们来看一下公平锁的加锁核心方法`tryAcquire`:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70_pic_center 5]

## 解锁流程 ##

解锁流程没有太多的自定义操作直接调用AQS解锁即可，具体可以看博主的其他文献。  
[ASQ分析1-基于AQS自定义锁分析][ASQ_1-_AQS]

# 非公平锁 #

## 加锁流程 ##

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

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

不管有没有加锁，直接线程CAS进行测试，测试成功就直接上设置独占锁线程然后返回，不在构造线程节点

//NonfairSync.java
     final void lock() {
        
          if (compareAndSetState(0, 1))
             setExclusiveOwnerThread(Thread.currentThread());
          else
               acquire(1);
    }

如果获取锁失败

//AbstractQueueSynchronizer.java
    public final void acquire(int arg) {
        
            if (!tryAcquire(arg) &&
                acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
                selfInterrupt();
        }

//AbstractQueueSynchronizer.java
     protected final boolean tryAcquire(int acquires) {
        
                return nonfairTryAcquire(acquires);
            }

//AbstractQueueSynchronizer.java
       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;
            }

源码比较简单没有太多讲解

## 解锁流程 ##

和加锁一样调用`AQS`原始的解锁机制。

# 参考 #

https://cloud.tencent.com/developer/article/1152651

[AQS_1-_AQS]: http://https://blog.csdn.net/qfanmingyiq/article/details/108279712
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/f787aba58d454413ab4e3578c701e06e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/acda9586d734407cb3c8e8cf75ca3d80.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/90c2739d678541ed8bb5c48a854ee2d9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/acc9437395f44ee299b96bff5f0a014b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221123/87e15bb2bdd149b0be386f8a22978f56.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221123/c087133ddf454bbfb3bf1273d6e21b23.png
[ASQ_1-_AQS]: https://blog.csdn.net/qfanmingyiq/article/details/108279712