//共享變量，使用volatile修飾保證線程可見性
private volatile int state;
//狀態(tài)信息通過protected類型的getState，setState，compareAndSetState進行操作. 且為final類型，不允許被子類重寫
//返回同步狀態(tài)的當(dāng)前值
protected final int getState() {
        return state;
}
 // 設(shè)置同步狀態(tài)的值
protected final void setState(int newState) {
        state = newState;
}
//原子地（CAS操作）將同步狀態(tài)值設(shè)置為給定值update如果當(dāng)前同步狀態(tài)的值等于expect（期望值）
protected final boolean compareAndSetState(int expect, int update) {
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

isHeldExclusively()//該線程是否正在獨占資源。只有用到condition才需要去實現(xiàn)它。
tryAcquire(int)//獨占方式。嘗試獲取資源，成功則返回true，失敗則返回false。
tryRelease(int)//獨占方式。嘗試釋放資源，成功則返回true，失敗則返回false。
tryAcquireShared(int)//共享方式。嘗試獲取資源。負數(shù)表示失??；0表示成功，但沒有剩余可用資源；正數(shù)表示成功，且有剩余資源。
tryReleaseShared(int)//共享方式。嘗試釋放資源，成功則返回true，失敗則返回false。

class MySync extends AbstractQueuedSynchronizer {
        // 嘗試去獲取鎖
        @Override
        protected boolean tryAcquire(int i) {
            // compareAndSetState(0, 1): 嘗試著將state的值從 0改為1
            if (compareAndSetState(0, 1)) {
                // 將持有鎖的線程改為當(dāng)前線程
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }
        // 嘗試去釋放鎖
        @Override
        protected boolean tryRelease(int i) {
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }
        // 判斷是否持有獨占鎖
        @Override
        protected boolean isHeldExclusively() {
            return getState() == 1;
        }
        protected Condition newCondition() {
            return new ConditionObject();
        }
    }

public class MyLock implements Lock {
    // 自定義同步器 , 實現(xiàn)的是不可重入鎖
    private MySync sync = new MySync();
    @Override
    // 嘗試，不成功，進入等待隊列
    public void lock() {
        sync.acquire(1);
    }
    @Override
    // 嘗試，不成功，進入等待隊列，可打斷
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }
    @Override
    // 嘗試一次，不成功返回，不進入隊列
    public boolean tryLock() {
        return sync.tryAcquire(1);
    }
    @Override
    // 嘗試，不成功，進入等待隊列，有時限
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(time));
    }
    @Override
    // 釋放鎖
    public void unlock() {
        sync.release(1);
    }
    @Override
    // 生成條件變量
    public Condition newCondition() {
        return sync.newCondition();
    }
}

@Slf4j(topic = "c.MyLockTest")
public class MyLockTest {
    public static void main(String[] args) {
        MyLock lock = new MyLock();
        new Thread(() -> {
            lock.lock();
            try {
                log.debug("locking...");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            } finally {
                log.debug("unlocking...");
                lock.unlock();
            }
        },"t1").start();
        new Thread(() -> {
            lock.lock();
            try {
                log.debug("locking...");
            } finally {
                log.debug("unlocking...");
                lock.unlock();
            }
        },"t2").start();
    }
}