基于reentrantlock，引用其思想和部分代码进行整合，并进行注释

    2. /**
    3.  * Created by zhaohui on 2021/5/1.
    4.  */
    5. public interface Lock {
    7.     void lock();
    9.     void unlock();
    10. }
    1. package com.example.zhaohui.lock;
    3. import org.springframework.aop.ThrowsAdvice;
    4. import sun.misc.Unsafe;
    6. import java.lang.reflect.Field;
    7. import java.util.concurrent.locks.LockSupport;
    9. /**
    10.  * Created by zhaohui on 2021/5/1.
    11.  */
    12. public class MyLock implements Lock {
    14.     private volatile int state;
    16.     private volatile Thread exclusiveOwnerThread;
    18.     private Node head;
    20.     private Node tail;
    22.     static final class Node{
    23.         Node next;
    24.         Node prev;
    25.         Thread thread;
    26.         Node(Thread t){
    27.             this.thread = t;
    28.         }
    29.         Node(){};
    30.     }
    32.     /**
    33.      *  抢占时如果锁被占用，则阻塞调用者的线程，直至抢占成功
    34.      *  模拟先来后到的公平锁。
    35.      *  1、 第一次进来发现state = 0 抢锁。
    36.      *  2、state>0 ，将当前线程加入到队列里
    37.      */
    38.     @Override
    39.     public void lock() {
    40.         acquire(1);
    41.     }
    43.     //尝试获取，成功则返回
    44.     //失败则阻塞
    45.     private void acquire(int arg) {
    46.         // 抢占失败了，将他们放到阻塞队列里然后挂起
    47.         // 在被唤醒时，要看看当前线程是否是head.next
    48.         // head.next节点是唯一拥有抢占权的线程
    49.         // 抢占成功将当前node设为head，并出队老head
    50.         // 失败继续挂起等待被唤醒
    51.         /**
    52.          *  添加到阻塞队列 -> addWaiter()
    53.          *  竞争资源   -> acquireQueued()
    54.          */
    55.         if(!tryAcquire(arg)){
    56.             Node node = addWaiter();
    57.             acquireQueued(node,arg);
    58.         }
    59.     }
    61.     // 尝试获取，不阻塞线程
    62.     private boolean tryAcquire(int arg) {
    63.         if(state == 0){
    64.             // state=0时不能直接拿锁，要看看前面有没有等待的线程
    65.             if(!hasQueuedPredecessor() && compareAndSetState(0,arg)){
    66.                 //抢锁成功
    67.                 exclusiveOwnerThread = Thread.currentThread();
    68.                 return true;
    69.             }
    70.         // 代码至此，当前锁是被占用的，看看是不是自己占用的，因为可重入
    71.         }else if(Thread.currentThread() == exclusiveOwnerThread){
    72.             state += arg;
    73.         }
    74.         // cas失败 stat>0且当前线程不是独占线程，需要将这些加入到阻塞队列里
    75.         return false;
    76.     }
    78.     // true -> 有等待线程
    79.     // false ->  无等待线程
    80.     private boolean hasQueuedPredecessor() {
    81.         // state为0时，在抢占前先看看有没有线程在等待
    82.         // 返回false的情况，当队列为null；当前线程为head.next，head.next有权利去获取锁，及当前线程就是后置节点
    83.         Node h = head;
    84.         Node t = tail;
    85.         Node s;
    86.         /**
    87.          *   h != t
    88.          *      成立：说明队列已经有node存在
    89.          *      不成立：1、 h == t == null 2、h == t == head（第一个抢占失败的线程会为当前线程持有的线程创建一个空的node节点，后head和tail都指向它）
    90.          *   (s = h.next) == null || s.thread != Thread.currentThread()
    91.          *      首先可肯定 条件1已经成立，队列已经存在
    92.          *      (s = h.next) == null  很极端，因为基于第一个条件下，几乎不会为空，即几乎总是返回true
    93.          *      s.thread != Thread.currentThread() 到此则说明 (s = h.next) != null,如果head的后置节点不是自己，即无权
    94.          */
    95.         return h != t && ((s = h.next) == null || s.thread != Thread.currentThread());
    96.     }
    98.     // addWaiter保证入队必须成功
    99.     private Node addWaiter(){
    100.         Node newNode = new Node(Thread.currentThread());
    101.         Node pred = tail;
    102.         if(pred != null){
    103.             if(compareAndSetTail(pred,newNode)){
    104.                 pred.next = newNode;
    105.                 return newNode;
    106.             }
    107.         }
    108.         // 到此，尾节点为空，cas失败,则循环保证其入队
    109.         enq(newNode);
    111.         return newNode;
    112.     }
    115.     private void enq(Node newNode) {
    116.         for(;;){
    117.             //1.队列为空,当前线程是第一个抢占失败的线程
    118.             //当前持有锁的线程并没有设置过任何node，所以作为该线程的第一个后继节点则需要为它补充一个node节点
    119.             //head任何时候都表示持有锁的线程
    120.             if(tail == null){
    121.                 //补充node，也不要设置占用线程
    122.                 if(compareAndSetHead(new Node())){
    123.                     head = tail;
    124.                 }
    125.             }else {
    126.                 Node pred = tail;
    127.                 if(pred != null){
    128.                     //入队成功退出即可
    129.                     if(compareAndSetTail(pred,newNode)){
    130.                         pred.next = newNode;
    131.                         return;
    132.                     }
    133.                 }
    134.             }
    135.         }
    136.     }
    138.     /**
    139.      * 获取到锁再退出自旋
    140.      * 当前线程是head的next节点才能有权限获取锁
    141.      * @param node
    142.      */
    143.     private void acquireQueued(Node node,int arg){
    144.         for (;;){
    145.             Node pred = node.prev;
    146.             // 此条件成立，说明当前node有权限去抢占,去试试
    147.             if(pred == head &&  tryAcquire(arg)){
    148.                 //抢占成功，将此节点设置为head 并将原head节点出队
    149.                 setHead(node);
    150.                 pred.next = null; //help gc
    151.                 return;
    152.             }
    153.             //如果当前线程不是head.next，或者并发下抢占失败了 需要挂起
    154.             System.out.println("线程：" + Thread.currentThread().getName() + "挂起");
    155.             LockSupport.park();
    156.             System.out.println("线程：" + Thread.currentThread().getName() + "唤醒");
    157.         }
    158.     }
    160.     @Override
    161.     public void unlock() {
    162.         release(1);
    164.     }
    166.     private void release(int arg){
    167.         // 释放锁了 可以去看看队列里是否有等待的线程进行唤醒
    168.         if(tryRelease(arg)){
    169.             Node h = head;
    171.             //看看是否有等待线程 h.next == null 则没有
    172.             if(h.next != null){
    173.                 //唤醒h.next
    174.                 unParkSuccessor(h);
    175.             }
    176.         }
    177.     }
    179.     private void unParkSuccessor(Node node){
    180.         Node s = node.next;
    181.         if(s != null && s.thread != null){
    182.             LockSupport.unpark(s.thread);
    183.         }
    184.     }
    186.     // state 减为0 返回true
    187.     public boolean tryRelease(int arg){
    188.         int c = state - arg;
    189.         if(exclusiveOwnerThread != Thread.currentThread()){
    190.             throw new Error("无权限");
    191.         }
    192.         if(c == 0){
    193.             exclusiveOwnerThread = null;
    194.             state = c;
    195.             return true;
    196.         }
    198.         state = c;
    199.         return false;
    201.     }
    203.     public Node getHead() {
    204.         return head;
    205.     }
    207.     public void setHead(Node node) {
    208.         this.head = node;
    209.         //当前node已经是获取锁成功的线程了
    210.         node.thread = null;
    211.         // 当前node成为头结点，则需要将原来前置引用去掉
    212.         node.prev = null;
    214.     }
    216.     public Node getTail() {
    217.         return tail;
    218.     }
    220.     public void setTail(Node tail) {
    221.         this.tail = tail;
    222.     }
    224.     private static final Unsafe unsafe;
    225.     private static final long stateOffset;
    226.     private static final long headOffset;
    227.     private static final long tailOffset;
    229.     static {
    230.         try{
    231.             Field field = Unsafe.class.getDeclaredField("theUnsafe");
    232.             field.setAccessible(true);
    233.             unsafe = (Unsafe) field.get(null);
    235.             stateOffset = unsafe.objectFieldOffset(MyLock.class.getDeclaredField("state"));
    236.             headOffset = unsafe.objectFieldOffset(MyLock.class.getDeclaredField("head"));
    237.             tailOffset = unsafe.objectFieldOffset(MyLock.class.getDeclaredField("tail"));
    238.         } catch (Exception e) {
    239.             throw new Error(e);
    240.         }
    241.     }
    243.     private final boolean compareAndSetHead(Node head){
    244.         return unsafe.compareAndSwapObject(this,headOffset,null,head);
    245.     }
    246.     private final boolean compareAndSetTail(Node expect,Node tail){
    247.         return unsafe.compareAndSwapObject(this,tailOffset,expect,tail);
    248.     }
    249.     private final boolean compareAndSetState(int expect,int update){
    250.         return unsafe.compareAndSwapObject(this,stateOffset,expect,update);
    251.     }
    252. }