0、AQS 原理说明

0.1、同步队列（FIFO) - 节点 (ADT)

0.2、同步状态

0.3、锁持有线程

0.4、条件队列（condition）

11、下面结合锁的独占/共享2种特性，以及独占/共享下公平和非公平的具体实现，以及在细化到公平/非公平下的重入和不可重入的具体实现

  1. private transient volatile Node head;    // CLH队列的队首
  2. private transient volatile Node tail;    // CLH队列的队尾
  4. // CLH队列的节点
  5. static final class Node {
  6.     static final Node SHARED = new Node();
  7.     static final Node EXCLUSIVE = null;
  9.     // 线程已被取消，对应的waitStatus的值
  10.     static final int CANCELLED =  1;
  11.     // “当前线程的后继线程需要被unpark(唤醒)”，对应的waitStatus的值。
  12.     // 一般发生情况是：当前线程的后继线程处于阻塞状态，而当前线程被release或cancel掉，因此需要唤醒当前线程的后继线程。
  13.     static final int SIGNAL    = -1;
  14.     // 线程(处在Condition休眠状态)在等待Condition唤醒，对应的waitStatus的值
  15.     static final int CONDITION = -2;
  16.     // (共享锁)其它线程获取到“共享锁”，对应的waitStatus的值
  17.     static final int PROPAGATE = -3;
  19.     // waitStatus为“CANCELLED, SIGNAL, CONDITION, PROPAGATE”时分别表示不同状态，
  20.     // 若waitStatus=0，则意味着当前线程不属于上面的任何一种状态。
  21.     volatile int waitStatus;
  23.     // 前一节点
  24.     volatile Node prev;
  26.     // 后一节点
  27.     volatile Node next;
  29.     // 节点所对应的线程
  30.     volatile Thread thread;
  32.     // nextWaiter是“区别当前CLH队列是 ‘独占锁’队列 还是 ‘共享锁’队列 的标记”
  33.     // 若nextWaiter=SHARED，则CLH队列是“独占锁”队列；
  34.     // 若nextWaiter=EXCLUSIVE，(即nextWaiter=null)，则CLH队列是“共享锁”队列。
  35.     Node nextWaiter;
  37.     // “共享锁”则返回true，“独占锁”则返回false。
  38.     final boolean isShared() {
  39.         return nextWaiter == SHARED;
  40.     }
  42.     // 返回前一节点
  43.     final Node predecessor() throws NullPointerException {
  44.         Node p = prev;
  45.         if (p == null)
  46.             throw new NullPointerException();
  47.         else
  48.             return p;
  49.     }
  51.     Node() {    // Used to establish initial head or SHARED marker
  52.     }
  54.     // 构造函数。thread是节点所对应的线程，mode是用来表示thread的锁是“独占锁”还是“共享锁”。
  55.     Node(Thread thread, Node mode) {     // Used by addWaiter
  56.         this.nextWaiter = mode;
  57.         this.thread = thread;
  58.     }
  60.     // 构造函数。thread是节点所对应的线程，waitStatus是线程的等待状态。
  61.     Node(Thread thread, int waitStatus) { // Used by Condition
  62.         this.waitStatus = waitStatus;
  63.         this.thread = thread;
  64.     }
  65. }

1、独占锁（一）：

1.1、获取锁：公平与非公平入队列的步骤以及区别？

1.1.1、公平锁：

1.1.1.1、可重入

1.1.1.2、不可重入

1.1.2、非公平锁：默认

1.1.2.1、可重入

1.1.2.2、不可重入

独占锁模式下，实现非公平可重入的ReentrantLock ，被阻塞线程入队列的区别？
前驱节点 是头节点（队列还没有创建）：1、首先T2线程与T1争抢锁时算一次
2.1、判断前驱节点prve 是否为 NULL 头节点。
2.2、创建自己节点初始化队列，再次尝试获取一次。
前驱节点不是 头节点：直接创建节点，入队列，设置前驱节点waitstate = -1；

1.2、释放锁：公平与非公平的步骤以及区别？

1.2.1、公平锁：

1.2.1.1、可重入

1.2.1.2、不可重入

1.2.2、非公平锁：

1.2.2.1、可重入

1.2.2.2、不可重入

2、共享锁（二）：

2.1、获取锁：公平与非公平入队列的步骤以及区别？

2.1.1、公平锁：

2.1.2、非公平锁：

2.2、释放锁：公平与非公平的步骤以及区别？

2.2.1、公平锁：

2.2.2、非公平锁：