深入解析 Java 併發編程：從 3 大特性到 AbstractQueuedSynchronizer 的應用 | Volatile

// 手寫不可重入鎖

public class OccupyHandlerLock implements Lock {

    private static class MySync extends AbstractQueuedSynchronizer {

        private static final long serialVersionUID = -6564653263134789293L;
        private static final int UNLOCKED = 0;
        private static final int LOCKED = 1;

        // 鎖是否已被持有
        @Override
        protected boolean isHeldExclusively() {
            // 返回同步狀態的值，該值使用 volatile 修飾
            return getState() == LOCKED;		// 自己設定為 1 時為鎖住的狀態
        }

        // 獲取鎖
        @Override
        protected boolean tryAcquire(int arg) {
            if(compareAndSetState(UNLOCKED, LOCKED)) {
                // 設置排他的執行序
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        // 釋放鎖
        @Override
        protected boolean tryRelease(int arg) {
            if(getState() == UNLOCKED) {
                throw new IllegalMonitorStateException();
            }

            if(compareAndSetState(LOCKED, UNLOCKED)) {
                // null 表示沒有任何執行序持有該鎖
                setExclusiveOwnerThread(null);
                return true;
            }
            return false;
        }

        // Condition 為一個接口
        Condition newCondition() {
            /**
             * 會 new 出一個 狀態為 condition 的 Node，並切換到隊列的頭節點
             */
            return new ConditionObject();	// AQS 提供的一個內部類
        }

    }

    // -----------------------------------------------------------------

    private MySync mySync = new MySync();

    @Override
    public void lock() {
        System.out.println(Thread.currentThread().getName() + " Ready Get Lock");
        mySync.acquire(MySync.LOCKED);
        System.out.println(Thread.currentThread().getName() + " Get Lock !!!");
    }

    @Override
    public void unlock() {
        System.out.println(Thread.currentThread().getName() + " Ready Release Lock");
        mySync.release(MySync.UNLOCKED);
        System.out.println(Thread.currentThread().getName() + " Release Lock !!!");
    }

    @Override
    public boolean tryLock() {
        return mySync.tryAcquire(MySync.LOCKED);
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        // 未實現
        return mySync.tryAcquireNanos(MySync.LOCKED, unit.toNanos(time));
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {
        // 該方法會對當前線程發出中斷信號，並且把參數發置 tryAcquire
        mySync.acquireInterruptibly(MySync.LOCKED);
    }

    @Override
    public Condition newCondition() {
        return mySync.newCondition();
    }

    public boolean isLocked() {
        return mySync.isHeldExclusively();
    }

    public boolean isQueueHasTask() {
        return mySync.getQueueLength() > 0;
    }

}

// 創建可重入鎖 （相同執行序才可以進入）
public class SharedHandlerLock implements Lock {

    private static class MySync_2 extends AbstractQueuedSynchronizer {

        private static final long serialVersionUID = -8298045247459685714L;
        private static final int UNLOCKED = 0;
        private static final int LOCKED = 1;

        @Override
        protected boolean isHeldExclusively() {
            return getState() > 0;	// 重入超過一個就算是以鎖住
        }

        @Override
        protected boolean tryAcquire(int arg) {
            //Thread now = Thread.currentThread();
            if(compareAndSetState(UNLOCKED, LOCKED)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;

            } else if(getExclusiveOwnerThread() == Thread.currentThread()) {	// 只有同線程 才可重入
                setState(getState() + 1); // 重點 ！！！ 仍然是 0 才是釋放
                return true;

            }
            return false;
        }

        @Override
        protected boolean tryRelease(int arg) {
            // 如果不是當前的執行序就「不釋放」
            if(getExclusiveOwnerThread() != Thread.currentThread()) {
                throw new IllegalMonitorStateException();
            }

            if (getState() == UNLOCKED) {	// 已沒有鎖住
                throw new IllegalMonitorStateException();
            }

            setState(getState() - 1);
            if(getState() == 0) {
                setExclusiveOwnerThread(null);
                System.out.println("Release Finish");
            } else {
                System.out.println("Release Havn't Done: " + getState());
            }

            return true;
        }

        Condition newCondition() {
            return new ConditionObject();
        }
    }

    // -----------------------------------------------------------------
    private MySync_2 mySync = new MySync_2();

    @Override
    public void lock() {
        System.out.println(Thread.currentThread().getName() + " Ready Get Lock");
        mySync.acquire(MySync_2.LOCKED);
        System.out.println(Thread.currentThread().getName() + " Get Lock !!!");
    }

    @Override
    public void unlock() {
        System.out.println(Thread.currentThread().getName() + " Ready Release Lock");
        mySync.release(MySync_2.UNLOCKED);
        System.out.println(Thread.currentThread().getName() + " Release Lock !!!");
    }

    @Override
    public boolean tryLock() {
        return mySync.tryAcquire(MySync_2.LOCKED);
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        // 未實現
        return mySync.tryAcquireNanos(MySync_2.LOCKED, unit.toNanos(time));
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {
        // 該方法會對當前線程發出中斷信號，並且把參數發置 tryAcquire
        mySync.acquireInterruptibly(MySync_2.LOCKED);
    }

    @Override
    public Condition newCondition() {
        return mySync.newCondition();
    }

    public boolean isLocked() {
        return mySync.isHeldExclusively();
    }

    public boolean isQueueHasTask() {
        return mySync.getQueueLength() > 0;
    }
}

Thread-2 Start
Thread-1 Start
Thread-1 Ready Get Lock
Thread-0 Start
Thread-1 Get Lock !!!
Thread-2 Ready Get Lock
Thread-1 遞歸層：3
Thread-1 Ready Get Lock
Thread-0 Ready Get Lock
Thread-1 Get Lock !!!
Thread-1 遞歸層：2
Thread-1 Ready Get Lock
Thread-1 Get Lock !!!
Thread-1 遞歸層：1
Thread-1 Release
Thread-1 Ready Release Lock
Release Havn't Done: 2
Thread-1 Release Lock !!!
Thread-1 Release
Thread-1 Ready Release Lock
Release Havn't Done: 1
Thread-1 Release Lock !!!
Thread-1 Release
Thread-1 Ready Release Lock
Release Finish
Thread-1 Release Lock !!!
Thread-2 Get Lock !!!
Thread-2 遞歸層：3
Thread-2 Ready Get Lock
Thread-2 Get Lock !!!
Thread-2 遞歸層：2
Thread-2 Ready Get Lock
Thread-2 Get Lock !!!
Thread-2 遞歸層：1
Thread-2 Release
Thread-2 Ready Release Lock
Release Havn't Done: 2
Thread-2 Release Lock !!!
Thread-2 Release
Thread-2 Ready Release Lock
Release Havn't Done: 1
Thread-2 Release Lock !!!
Thread-2 Release
Thread-2 Ready Release Lock
Release Finish
Thread-2 Release Lock !!!
Thread-0 Get Lock !!!
Thread-0 遞歸層：3
Thread-0 Ready Get Lock
Thread-0 Get Lock !!!
Thread-0 遞歸層：2
Thread-0 Ready Get Lock
Thread-0 Get Lock !!!
Thread-0 遞歸層：1
Thread-0 Release
Thread-0 Ready Release Lock
Release Havn't Done: 2
Thread-0 Release Lock !!!
Thread-0 Release
Thread-0 Ready Release Lock
Release Havn't Done: 1
Thread-0 Release Lock !!!
Thread-0 Release
Thread-0 Ready Release Lock
Release Finish
Thread-0 Release Lock !!!