使用CAS+AQS+LockSupprot手写Lock锁

import java.util.concurrent.ConcurrentLinkedDeque;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.LockSupport;

public class Lock {
    /**
     * 共享状态变量
     */
    private AtomicInteger lockStatus = new AtomicInteger(0);

    /**
     * 存放当前线程
     */
    private Thread currentThread;

    /**
     * 阻塞队列
     */
    private ConcurrentLinkedDeque<Thread> deque = new ConcurrentLinkedDeque<>();

    /**
     * 获取锁
     *
     * @return Boolean
     */
    private Boolean lock(){
        for (;;){
            //判断是否CAS是否成功
            if (lockStatus.compareAndSet(0,1)){
                //成功则缓存当前线程
                currentThread = Thread.currentThread();
                return true;
            }
            //失败则将线程放入阻塞队列，并阻塞线程
            Thread thread = Thread.currentThread();
            deque.add(thread);
            LockSupport.park();
        }

    }
    
    /**
     * 释放锁
     *
     * @return Boolean
     */
    private Boolean unLock(){
        //先判断线程是否为null
        if (null == currentThread){
            return false;
        }
        //判断是否是当前线程持有
        if (currentThread == Thread.currentThread()){
            //在判断线程是否CAS成功
            if (lockStatus.compareAndSet(1,0)){
                //成功则唤醒线程
                //分为公平唤醒和非公平唤醒
                Thread thread = deque.getFirst();
                LockSupport.unpark(thread);
                return true;
            }
        }
        return false;
    }
}