如何手写一个AQS？

// 阻塞线程
LockSupport.park(this)
// 唤醒线程
LockSupport.unpark(this)

static final class Node {
 //表示当前线程以共享模式持有锁
 static final Node SHARED = new Node();
 //表示当前线程以独占模式持有锁
 static final Node EXCLUSIVE = null;

 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;

 //存储在condition队列中的后继节点
 Node nextWaiter;

}

//等待队列的头节点
private transient volatile Node head;

//等待队列的尾节点
private transient volatile Node tail;

//加锁的状态，在不同子类中有不同的意义
private volatile int state;

// 调用ReentrantLock.FairSync#lock方法其实就是调用acquire(1);
public final void acquire(int arg){
 if (!tryAcquire(arg) &&
  acquireQueued(addWaiter(Node.EXCLUSIVE), arg))//获取到锁返回false，否则返回true
  selfInterrupt();//当前线程将自己中断
}

protected boolean tryAcquire(int arg){
 throw new UnsupportedOperationException();
}

private Node addWaiter(Node mode){
 Node node = new Node(Thread.currentThread(), mode);
 Node pred = tail;
 if (pred != null) {
  node.prev = pred;
  if (compareAndSetTail(pred, node)) {
   pred.next = node;
   return node;
  }
 }
 enq(node);
 return node;
}

private Node enq(final Node node){
 for (;;) {
  Node t = tail;
  // 队列为空，进行初始化，
  if (t == null) {
   if (compareAndSetHead(new Node()))
    tail = head;
  } else {
   node.prev = t;
   if (compareAndSetTail(t, node)) {
    t.next = node;
    return t;
   }
  }
 }
}

// 自旋获取锁，直到获取锁成功，或者异常退出
// 但是并不是busy acquire，因为当获取失败后会被挂起，由前驱节点释放锁时将其唤醒
// 同时由于唤醒的时候可能有其他线程竞争，所以还需要进行尝试获取锁，体现的非公平锁的精髓。
final boolean acquireQueued(final Node node, int arg){
 boolean failed = true;
 try {
  boolean interrupted = false;
  for (;;) {
   // 获取前继节点
   final Node p = node.predecessor();
   // node节点的前继节点是head节点，尝试获取锁，如果成功说明head节点已经释放锁了
   // 将node设为head开始运行(head中不包含thread)
   if (p == head && tryAcquire(arg)) {
    setHead(node);
    // 将第一个节点出队
    p.next = null; // help GC
    failed = false;
    return interrupted;
   }
   // 获取锁失败后是否可以挂起
   // 如果可以挂起，则阻塞当前线程（获取锁失败的节点）
   if (shouldParkAfterFailedAcquire(p, node) &&
    parkAndCheckInterrupt())
    interrupted = true;
  }
 } finally {
  if (failed)
   cancelAcquire(node);
 }
}

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node){
 int ws = pred.waitStatus;
 // 前继节点释放时会unpark后继节点，可以挂起
 if (ws == Node.SIGNAL)
  return true;
 if (ws > 0) {
  //将CANCELLED状态的线程清理出队列
  // 后面会提到为什么会有CANCELLED的节点
  do {
   node.prev = pred = pred.prev;
  } while (pred.waitStatus > 0);
  pred.next = node;
 } else {
  // 将前继节点的状态设置为SIGNAL，代表释放锁时需要唤醒后面的线程
  // cas更新可能失败，所以不能直接返回true
  compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
 }
 return false;
}

// 挂起线程，返回是否被中断过
private final boolean parkAndCheckInterrupt(){
 // 阻塞线程
 LockSupport.park(this);
 // 返回当前线程是否被调用过Thread#interrupt方法
 return Thread.interrupted();
}

//处理异常退出的node
private void cancelAcquire(Node node) {
 if (node == null)
  return;

 // 设置该节点不再关联任何线程
 node.thread = null;

 // 跳过CANCELLED节点，找到一个有效的前继节点
 Node pred = node.prev;
 while (pred.waitStatus > 0)
  node.prev = pred = pred.prev;

 // 获取过滤后的有效节点的后继节点
 Node predNext = pred.next;

 // 设置状态为取消
 node.waitStatus = Node.CANCELLED;

 // case 1
 if (node == tail && compareAndSetTail(node, pred)) {
  compareAndSetNext(pred, predNext, null);
 } else {
  // case 2
  int ws;
  if (pred != head &&
   ((ws = pred.waitStatus) == Node.SIGNAL ||
    (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
   pred.thread != null) {
   Node next = node.next;
   if (next != null && next.waitStatus <= 0)
    compareAndSetNext(pred, predNext, next);
  } else {
   // case3
   unparkSuccessor(node);
  }

  node.next = node; // help GC
 }
}

// 调用ReentrantLock#unlock方法其实就是调用release(1)
public final boolean release(int arg){
 // 尝试释放锁
 // 当state=0，表示锁被释放，tryRelease返回true，此时需要唤醒阻塞队列中的线程
 if (tryRelease(arg)) {
  Node h = head;
  if (h != null && h.waitStatus != 0)
   unparkSuccessor(h);
  return true;
 }
 return false;
}

private void unparkSuccessor(Node node){

 int ws = node.waitStatus;
 if (ws < 0)
  compareAndSetWaitStatus(node, ws, 0);

 // 头结点的下一个节点
 Node s = node.next;
 // 为空或者被取消
 if (s == null || s.waitStatus > 0) {
  s = null;
  // 从队列尾部向前遍历找到最前面的一个waitStatus<=0的节点
  for (Node t = tail; t != null && t != node; t = t.prev)
   if (t.waitStatus <= 0)
    s = t;
 }
 if (s != null)
  // 唤醒节点,但并不表示它持有锁，要从阻塞的地方开始运行
  LockSupport.unpark(s.thread);
}

private Node addWaiter(Node mode){
    Node node = new Node(Thread.currentThread(), mode);
    // Try the fast path of enq; backup to full enq on failure
    Node pred = tail;
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
         // 线程在这里挂起了
            pred.next = node;
            return node;
        }
    }
    enq(node);
    return node;
}

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

public final void acquireInterruptibly(int arg)
         throws InterruptedException {
     // 判断线程是否被中断
     if (Thread.interrupted())
         throw new InterruptedException();
     if (!tryAcquire(arg))
         doAcquireInterruptibly(arg);
 }

private final boolean parkAndCheckInterrupt(){
 LockSupport.park(this);
 return Thread.interrupted();
}

@Test
public void testInterrupt() throws InterruptedException {
    Thread thread = new Thread(() -> {
        while (true) {}
    });
    thread.start();
    TimeUnit.MICROSECONDS.sleep(100);
    thread.interrupt();
    // true
    System.out.println(thread.isInterrupted());
    // true
    System.out.println(thread.isInterrupted());
    // true
    System.out.println(thread.isInterrupted());
}

@Test
public void testInterrupt2(){
    Thread.currentThread().interrupt();
    // true
    System.out.println(Thread.interrupted());
    // false
    System.out.println(Thread.interrupted());
    // false
    System.out.println(Thread.interrupted());
}

public static void main(String[] args){
 LockSupport.park();
 // end被一直阻塞没有输出
 System.out.println("end");
}

public static void main(String[] args){
 Thread.currentThread().interrupt();
 LockSupport.park();
 // 输出end
 System.out.println("end");
}

public static void main(String[] args){
 Thread.currentThread().interrupt();
 LockSupport.park();
 // 返回中断状态，并且清除中断状态
 Thread.interrupted();
 // 输出start
 System.out.println("start");
 LockSupport.park();
 // end被阻塞，没有输出
 System.out.println("end");
}

public class MyLock {

    private final Sync sync;

    public MyLock(){
        sync = new Sync();
    }

    public class Sync extends AbstractQueuedSynchronizer {

        @Override
        protected boolean tryAcquire(int arg){
            return compareAndSetState(0, arg);
        }

        @Override
        protected boolean tryRelease(int arg){
            setState(0);
            return true;
        }

    }

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

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