package lock.lock;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;

/**
 * 自定义实现的可重入锁
 */
public class MyReentrantLock {

    private static int testNumber = 0;
    private Sync sync;

    public MyReentrantLock() {
        this.sync = new Sync();
    }

    public static void main(String[] args) throws Exception {
        MyReentrantLock myMutexLock = new MyReentrantLock();
        CountDownLatch countDownLatch = new CountDownLatch(2);
        new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                myMutexLock.lock();
                try {
                    testNumber++;
                } finally {
                    myMutexLock.unlock();
                }
            }
            countDownLatch.countDown();
        }).start();

        new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                myMutexLock.lock();
                try {
                    testNumber++;
                } finally {
                    myMutexLock.unlock();
                }
            }
            countDownLatch.countDown();
        }).start();

        countDownLatch.await();
        System.out.println(testNumber);
        assert testNumber == 20000;
    }

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

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

    private class Sync extends AbstractQueuedSynchronizer {
        @Override
        protected boolean isHeldExclusively() {
            return getExclusiveOwnerThread() == Thread.currentThread();
        }

        @Override
        protected boolean tryAcquire(int arg) {
            if (getState() == 0) {
                if (compareAndSetState(0, arg)) {
                    setExclusiveOwnerThread(Thread.currentThread());
                    return true;
                }
            } else if (isHeldExclusively()) {
                int c = getState() + arg;
                setState(c);
                return true;
            }
            return false;
        }

        @Override
        protected boolean tryRelease(int arg) {
            if(!isHeldExclusively()){
                throw new IllegalMonitorStateException();
            }
            int newState = getState() - arg;
            setState(newState);
            if (newState == 0) {
                setExclusiveOwnerThread(null);
                return true;
            } else {
                return false;
            }
        }
    }
}

这个是自定义实现的独占锁，发现一个问题，把setState方法放到setExclusiveOwnerThread方法前面，执行单测会报错。。。，我debug发现报错的时候，
exclusiveOwnerThread属性为空。悟空老师能帮忙看下么