ReentrantLock源码解析（图解AQS）

- 日理万妓 2022-12-20 02:44 105阅读 0赞

# 1 同步队列（CLH） #

CLH队列是Craig, Landin, and Hagersten三人发明的一种基于双向链表数据结构的队列。是一种基于链表的可扩展、高性能、公平的自旋锁，申请线程仅仅在本地变量上自旋，它不断轮询前驱的状态，假设发现前驱释放了锁就结束自旋。  
JAVA中的CLH队列是原CLH队列的一个变种，线程由原来的自旋机制改为阻塞机制。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5_size_16_color_FFFFFF_t_70_pic_center]

# 2 AQS简介 #

## 2.1 定义 ##

(1) 全称是 AbstractQueuedSynchronizer  
(2) 阻塞式锁和相关的同步器工具的框架；  
(3) AQS用一个变量（volatile state） 属性来表示锁的状态，子类去维护这个状态  
(4) getState、compareAndSetState cas改变这个变量  
(5) 独占模式是只有一个线程能够访问资源  
(6) 而共享模式可以允许多个线程访问资源（读写锁）  
(7) 内部维护了一个FIFO等待队列，类似于 synchronized关键字当中的 Monitor 的 EntryList  
(8) 条件变量来实现等待、唤醒机制，支持多个条件变量，类似于 Monitor 的 WaitSet  
(9) 内部维护了一个Thread exclusiveOwnerThread 来记录当前持有锁的那个线程

## 2.2 功能 ##

(1) 实现阻塞获取锁 acquire 拿不到锁就去阻塞 等待锁被释放再次获取锁  
(2) 实现非阻塞尝试获取锁 tryAcquire 拿不到锁则直接放弃  
(3) 实现获取锁超时机制  
(4) 实现通过打断来取消  
(5) 实现独占锁及共享锁  
(6) 实现条件不满足的时候等待

# 3 节点 #

static final class Node { 
            
            /**################节点模式##################*/
            /** 共享*/
            static final Node SHARED = new Node();
            /** 独占 */
            static final Node EXCLUSIVE = null;
            /** * CANCELLED：等待线程超时或者被中断、需要从同步队列中取消等待（也就是放弃资源的竞争） * SIGNAL：后继节点会处于等待状态，当前节点线程如果释放同步状态或者被取消则会通知后继节点线程，使后继节点线程的得以运行 * CONDITION：节点在等待队列中，线程在等待在Condition 上，其他线程对Condition调用singnal()方法后，该节点加入到同步队列中。 * PROPAGATE：表示下一次共享式获取同步状态的时会被无条件的传播下去。 */
            static final int CANCELLED =  1;
            static final int SIGNAL    = -1;
            static final int CONDITION = -2;
            static final int PROPAGATE = -3;
            /**等待状态*/
            volatile int waitStatus;
            /**前指针*/
            volatile Node prev;
            /**后指针*/
            volatile Node next;
            /**线程*/
            volatile Thread thread;
    
            /** * AQS中条件队列是使用单向列表保存的，用nextWaiter来连接。 */
            Node nextWaiter;
            /** 判断nextWaiter是否为共享*/
            final boolean isShared() { 
                return nextWaiter == SHARED;
            }
            /**获取当前节点的前驱节点 */
            final Node predecessor() throws NullPointerException { 
                Node p = prev;
                if (p == null)
                    throw new NullPointerException();
                else
                    return p;
            }
            /** * ###################################### * ##############构造方法################ * ###################################### */    
            Node() {      
            }
            Node(Thread thread, Node mode) {      // Used by addWaiter
                this.nextWaiter = mode;
                this.thread = thread;
            }
            Node(Thread thread, int waitStatus) {  // Used by Condition
                this.waitStatus = waitStatus;
                this.thread = thread;
            }
        }

# 4 AQS主要属性 #

head、tail、state、exclusiveOwnerThread

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5_size_16_color_FFFFFF_t_70_pic_center 1]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5_size_16_color_FFFFFF_t_70_pic_center 2]

# 5 ReentrantLock #

## 5.1 ReentrantLock和AQS之间的关系 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5_size_16_color_FFFFFF_t_70_pic_center 3]

## 5.2 非公平锁加锁过程 ##

### 5.2.1 Demo ###

public class Account { 
    
        private static final ReentrantLock LOCK = new ReentrantLock();
    
        private int number;
    
        public Account(int number) { 
            this.number = number;
        }
    
        public void addNumber(int count) { 
            try { 
                LOCK.lock();
                number = number + count;
                Thread.sleep(1000);
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                LOCK.unlock();
            }
        }
    
        public int getNumber() { 
            return this.number;
        }
    
    }
    
    
    public class LockTest { 
    
    
        public static void main(String[] args) throws InterruptedException { 
    
            Account account = new Account(0);
            //创建
            Thread t1 = new Thread(() -> account.addNumber(100), "t1");
            Thread t2 = new Thread(() -> account.addNumber(100), "t2");
            Thread t3 = new Thread(() -> account.addNumber(100), "t3");
            //开启
            t1.start();
            t2.start();
            t3.start();
            //join
            t1.join();
            t2.join();
            t3.join();
            System.out.println(account.getNumber());
    
        }
    
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5_size_16_color_FFFFFF_t_70_pic_center 4]

### 5.2.2 AQS初始化状态 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5_size_16_color_FFFFFF_t_70_pic_center 5]

### 5.2.3 当t1加入时 ###

t1进来时队列没有CLH队列为空，及t1抢到了锁，compareAndSetState(0,1) 为true。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5_size_16_color_FFFFFF_t_70_pic_center 6]  
AQS状态：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5_size_16_color_FFFFFF_t_70_pic_center 7]

### 5.2.4 当t2加入时 ###

(1) 调用ReentrantLock NonfairSync内部类lock

static final class NonfairSync extends Sync { 
            private static final long serialVersionUID = 7316153563782823691L;
    
            /** * Performs lock. Try immediate barge, backing up to normal * acquire on failure. */
            final void lock() { 
                //t1睡眠1s，锁没有释放，t2进入acquire(1)
                if (compareAndSetState(0, 1))
                    setExclusiveOwnerThread(Thread.currentThread());
                else
                    acquire(1);
            }
    
            protected final boolean tryAcquire(int acquires) { 
                return nonfairTryAcquire(acquires);
            }
    }

(2) 调取AQS方法acquire

public final void acquire(int arg) { 
         
         //尝试获取锁、入队、等待
         if (!tryAcquire(arg) &&
                acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
                selfInterrupt();
     }

(3) 调取ReentrantLock NonfairSync内部类nonfairTryAcquire

final boolean nonfairTryAcquire(int acquires) { 
        final Thread current = Thread.currentThread();
        //获取状态
        int c = getState();
        //如果为0，并且抢到锁，返回尝试获取成功
        if (c == 0) { 
            if (compareAndSetState(0, acquires)) { 
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        //如果当前线程等于持有锁的线程，更新state的值，返回尝试获取成功
        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;
    }

(4) 调取AQS方法addWaiter(Node.EXCLUSIVE)

private Node addWaiter(Node mode) { 
            //创建一个node节点
            Node node = new Node(Thread.currentThread(), mode);
            // 获取队尾
            Node pred = tail;
            //如果队尾存在 
            if (pred != null) { 
                //把当前节点的prev设置成队尾，cas更新队尾，返回新建的节点
                node.prev = pred;
                if (compareAndSetTail(pred, node)) { 
                    pred.next = node;
                    return node;
                }
            }
            //初始化CLH队列
            enq(node);
            return node;
      }
        
        
     private Node enq(final Node node) { 
            //自旋
            for (;;) { 
                //获取队尾 
                Node t = tail;
                //如果队尾为空
                if (t == null) {  
                    //创建一个节点，设置为队头，队尾，继续自旋
                    if (compareAndSetHead(new Node()))
                        tail = head;
                } else { 
                    //更新队尾，设置新建节点的前驱为队尾，cas设置队尾，更新原队尾的后继节点
                    node.prev = t;
                    if (compareAndSetTail(t, node)) { 
                        t.next = node;
                        return t;
                    }
                }
            }
     }

(5) 调取AQS方法 acquireQueued

final boolean acquireQueued(final Node node, int arg) { 
            //标记acquireQueued方法是否执行成功
            boolean failed = true;
            try { 
                //标记，线程打断状态
                boolean interrupted = false;
                //自旋
                for (;;) { 
                    //获取新建节点的前驱节点
                    final Node p = node.predecessor();
                    //如果当前节点是第二个节点，并且抢到了锁
                    if (p == head && tryAcquire(arg)) { 
                        //更新队头
                        setHead(node);
                        p.next = null; // help GC
                        //标记acquireQueued方法执行成功
                        failed = false;
                        return interrupted;
                    }
                    //自旋第一次，cas设置前驱节点为SIGNAL状态(进入睡眠前，修改前驱节点状态，告诉它轮我工作时呼我)
                    //自旋第二次，执行parkAndCheckInterrupt()方法进入睡眠
                    if (shouldParkAfterFailedAcquire(p, node) &&
                        parkAndCheckInterrupt())
                        interrupted = true;
                }
            } finally { 
                if (failed)
                    cancelAcquire(node);
            }
      }

(6) AQS状态  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5_size_16_color_FFFFFF_t_70_pic_center 8]  
(7) CLH状态  
![在这里插入图片描述][20201110012429195.png_pic_center]

### 5.2.5 当t3加入时 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5_size_16_color_FFFFFF_t_70_pic_center 9]

## 5.3 解锁 ##

(1) ReentrantLock 调用方法  
![在这里插入图片描述][20201110010410472.png_pic_center]  
(2) AQS 调用方法

public final boolean release(int arg) { 
        //释放锁
        if (tryRelease(arg)) { 
            //获取头节点
            Node h = head;
            //头结点不能为空并且头结点状态不能是0，才能唤醒其它节点
            //PS:状态是0的节点是尾部节点
            if (h != null && h.waitStatus != 0)
                //唤醒
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

(3) ReentrantLock 调用方法tryRelease

protected final boolean tryRelease(int releases) { 
        //获取状态
        int c = getState() - releases;
        //判断当前线程是否是锁的持有线程
        if (Thread.currentThread() != getExclusiveOwnerThread())
       		 throw new IllegalMonitorStateException();
        //释放标记
        boolean free = false;
        //如果状态为0，释放标记更新成功，设置锁的持有线程为null
        if (c == 0) { 
     		 free = true;
       		 setExclusiveOwnerThread(null);
        }
        //更新状态
        setState(c);
        return free;
    }

(4) AQS 调取方法unparkSuccessor

private void unparkSuccessor(Node node) { 
            //获取头节点状态
            int ws = node.waitStatus;
            //如果状态为SIGNAL、CONDITION、PROPAGATE更新状态为0
            if (ws < 0)
                compareAndSetWaitStatus(node, ws, 0);
    		//获取头节点的下一个节点
            Node s = node.next;
            //如果下一个节点为null 或 无效的节点，从队尾往前找，找出最后一个有效的节点（head下第一个有效节点）
            if (s == null || s.waitStatus > 0) { 
                s = null;
                for (Node t = tail; t != null && t != node; t = t.prev)
                    if (t.waitStatus <= 0)
                        s = t;
            }
            //唤醒
            if (s != null)
                LockSupport.unpark(s.thread);
     }

## 5.4 公平锁和非公平锁加锁区别 ##

(1) lock方法不同  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5_size_16_color_FFFFFF_t_70_pic_center 10]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5_size_16_color_FFFFFF_t_70_pic_center 11]

(2) tryAcquire不同  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5_size_16_color_FFFFFF_t_70_pic_center 12]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5_size_16_color_FFFFFF_t_70_pic_center 13]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/4137e2af6b4f476f8a3e3bbaf5636652.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20201110010047202.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20201110010057429.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/2020111001011559.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5_size_16_color_FFFFFF_t_70_pic_center 4]: https://img-blog.csdnimg.cn/20201110010140609.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5_size_16_color_FFFFFF_t_70_pic_center 5]: https://img-blog.csdnimg.cn/2020111001015182.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5_size_16_color_FFFFFF_t_70_pic_center 6]: https://img-blog.csdnimg.cn/20201110010205358.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5_size_16_color_FFFFFF_t_70_pic_center 7]: https://img-blog.csdnimg.cn/20201110010214128.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5_size_16_color_FFFFFF_t_70_pic_center 8]: https://img-blog.csdnimg.cn/20201110010314799.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5,size_16,color_FFFFFF,t_70#pic_center
[20201110012429195.png_pic_center]: https://img-blog.csdnimg.cn/20201110012429195.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5_size_16_color_FFFFFF_t_70_pic_center 9]: https://img-blog.csdnimg.cn/20201110012530957.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5,size_16,color_FFFFFF,t_70#pic_center
[20201110010410472.png_pic_center]: https://img-blog.csdnimg.cn/20201110010410472.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5_size_16_color_FFFFFF_t_70_pic_center 10]: https://img-blog.csdnimg.cn/20201110010503197.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5_size_16_color_FFFFFF_t_70_pic_center 11]: https://img-blog.csdnimg.cn/20201110010508425.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5_size_16_color_FFFFFF_t_70_pic_center 12]: https://img-blog.csdnimg.cn/20201110010516674.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5_size_16_color_FFFFFF_t_70_pic_center 13]: https://img-blog.csdnimg.cn/20201110010552517.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MTI1OTk5,size_16,color_FFFFFF,t_70#pic_center