public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

即該執行緒阻塞時被中斷，拋中斷例外后執行緒退出，不會執行后面陳述句，
在interrupt過后，lock方法是不會中斷的，回應中斷

根據Lock介面的原始碼注釋，Lock介面的實作，具備和同步關鍵字同樣的記憶體語意，代碼在運行時并且不能指令重排，不會被快取

{@code Lock}實作提供了更廣泛的鎖定 使用{@code synchronized}方法可以獲得的操作和宣告，它們允許更靈活的結構，可能有完全不同的屬性，并且可能支持多個關聯的{@link Condition}物件，

ReentrantLock

ReentrantLock是lock介面的最經典實作，是一個可重入鎖、悲觀鎖、獨享鎖、自旋鎖；

默認是非公平鎖

   public ReentrantLock() {
        sync = new NonfairSync();
    }

可以在初始化時設定為公平鎖

  public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

重字面意思說reentrantlock是可重入的鎖，可重入的概念在于下面的 代碼執行過后

    static Lock lc = new ReentrantLock();
    static volatile int i = 0;
    public static void add() throws InterruptedException {
        lc.lock();
        i++;
        System.out.println("here im ..");
        Thread.sleep(1000L);
        add();

        lc.unlock();
    }

    public static void main(String args[]) throws InterruptedException {
        add();
    }

得到結果會一直列印值，
相同的執行緒，不互斥，會再次獲取到鎖，執行鎖內代碼，

reentrantlock怎么實作可重入鎖的，

首先實作一個簡單的不重入鎖

public class MyLock implements Lock {

    //當前鎖擁有者，若onwer為null，說明沒有執行緒占用鎖
    private Thread owner = null;
    //鎖占用是，執行緒被掛起，掛起的執行緒的參考被放到waiters佇列
    private BlockingQueue<Thread> waiters = new LinkedBlockingQueue<>();


    @Override
    public boolean tryLock() {  //嘗試獲取鎖
        //若鎖未占用
        if (owner == null){
            owner = Thread.currentThread();     //當前執行緒獲得鎖
            return true;        //獲得鎖，回傳true
        }else{
            return false;       //獲取鎖失敗，回傳false
        }
    }
    @Override
    public void lock() {
        while(!tryLock()){      //嘗試拿鎖，如果失敗，
            Thread curTh = Thread.currentThread();      //獲取當前執行緒參考
            waiters.offer(curTh);       //將當前執行緒參考放入等待佇列

            LockSupport.park();     
           
        }
    }
    @Override
    public void unlock() {  //釋放鎖
        if (owner == Thread.currentThread()){       //若確實是我占有了鎖
            owner = null;                           //將onwer置為null，釋放鎖
            Thread th = waiters.poll();     //取出佇列頭部的元素，并移除該元素
            LockSupport.unpark(th);           //喚醒佇列頭部的元素
        }
    }
  
}

這里只用一個owner來判斷當前那個鎖被占用 ，并用一個佇列來存盤阻塞執行緒

在ReentrantLock中去判斷是否重入鎖，需要添加State值，來判斷當前鎖是否被被占用

 protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

這里新加了個同步狀態來維護，

實作的一個簡單的可重入鎖

public class MyLock implements Lock {
    //鎖擁有者
    volatile AtomicReference<Thread> owner = new AtomicReference<>();

    //等待佇列
    private LinkedBlockingQueue<Thread> waiters = new LinkedBlockingQueue<>();

    //記錄重入的次數
    volatile AtomicInteger state = new AtomicInteger(0);

  @Override
	public boolean tryLock() {
		int s = state.get();
		if (s != 0) {
			// 判斷state是否為0，state！=0，說明鎖被占用
			if (owner.get() == Thread.currentThread()) {
				state.set(s + 1);
				return true;
			}
		} else {
			// 如state==0，說明鎖未未被占用，CAS操作來搶鎖，修改state的值
			while (state.compareAndSet(s, s + 1)) {
				owner.set(Thread.currentThread());
				return true;
			}
		}
		return false;
	}

    @Override
    public void lock() {
        if (!tryLock()){
            waiters.offer(Thread.currentThread());

            //自旋搶鎖
            for (;;){
                Thread head = waiters.peek();
        
                if (head == Thread.currentThread()){
                    if (!tryLock()){
                        LockSupport.park();
                    }else{
                        waiters.poll();
                        return;
                    }
                }else{
                    LockSupport.park();
                }
            }
        }
    }

    @Override
    public void unlock() {
        if (tryUnlock()){
            Thread th = waiters.peek();
            if (th !=null){
                LockSupport.unpark(th);
            }
        }
    }


    public boolean tryUnlock(){
        //判斷owner是不是自己
        if (owner.get() != Thread.currentThread()){
            throw new IllegalMonitorStateException();
        }else{
            //釋放鎖，state-1，
            int ct = state.get();
            int nextc = ct -1;
            state.set(nextc);

            //是不是一定將onwer該問null
            if (nextc == 0){
                owner.set(null);
                return true;
            }else{
                return false;
            }
        }
    }

}

這里主要是為了實作一個簡單的可重入鎖，因此并沒有考慮到其他情況

Condition