// 在main方法中，開啟100個(gè)線程執(zhí)行 lock() 方法
// 開啟10個(gè)線程執(zhí)行 unlock() 方法
// 此時(shí)進(jìn)行加鎖和解鎖之后，加鎖多于解鎖的時(shí)候，就會(huì)一直阻塞等待
public class Demo01 {
    private boolean isLocked = false;

    public synchronized void lock() throws InterruptedException {
        while (isLocked) {
            // 當(dāng)其他線程進(jìn)來，即處于等待阻塞狀態(tài)   
            wait();
        }
        System.out.println("Demo01.lock");
        isLocked = true;
    }

    public synchronized void unlock() {
        isLocked = false;
        System.out.println("Demo01.unlock");
        notify();
    }

    public static void main(String[] args) {
        Demo01 demo01 = new Demo01();
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                try {
                    demo01.lock();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                demo01.unlock();
            }).start();
        }
    }
}

// 非阻塞鎖
public class Demo02 {
    private boolean isLocked = false;

    public synchronized boolean lock() throws InterruptedException {
        if (isLocked) {
            return false;
        }
        System.out.println("Demo01.lock");
        isLocked = true;
        return true;
    }

    public synchronized boolean unlock() {
        if (isLocked) {
            System.out.println("Demo01.unlock");
            isLocked = !isLocked;
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        Demo02 demo01 = new Demo02();
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                try {
                    if (demo01.lock()) {
                        System.out.println("獲取鎖失敗");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
        for (int i = 0; i < 1000; i++) {
            new Thread(() -> {
                if (demo01.unlock()) {
                    System.out.println("解鎖成功");
                }
            }).start();
        }
    }
}

public class Test implements Runnable {

    public synchronized void get() {
        System.out.println(Thread.currentThread().getId());
        set();
    }

    public synchronized void set() {
        System.out.println(Thread.currentThread().getId());
    }

    @Override
    public void run() {
        get();
    }

    public static void main(String[] args) {
        Test ss = new Test();
        new Thread(ss).start();
        new Thread(ss).start();
        new Thread(ss).start();
    }
}
// 執(zhí)行結(jié)果
// 11
// 11
// 12
// 12
// 13
// 13

public class Test2 implements Runnable {
    ReentrantLock lock = new ReentrantLock();

    public void get() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getId());
            set();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void set() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getId());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    @Override
    public void run() {
        get();
    }

    public static void main(String[] args) {
        Test ss = new Test();
        new Thread(ss).start();
        new Thread(ss).start();
        new Thread(ss).start();
    }
}
// 執(zhí)行結(jié)果
// 11
// 11
// 12
// 12
// 13
// 13

public class SpinLock {
    private AtomicReference<Thread> owner = new AtomicReference<>();

    public void lock() {
        Thread current = Thread.currentThread();
        while (!owner.compareAndSet(null, current)) {
        }
    }

    public void unlock() {
        Thread current = Thread.currentThread();
        owner.compareAndSet(current, null);
    }

public class SpinLock1 {
    private AtomicReference<Thread> owner =new AtomicReference<>();
    private int count =0;
    public void lock(){
        Thread current = Thread.currentThread();
        if(current==owner.get()) {
            count++;
            return ;
        }
        while(!owner.compareAndSet(null, current)){
        }
    }
    public void unlock (){
        Thread current = Thread.currentThread();
        if(current==owner.get()){
            if(count!=0){
                count--;
            }else{
                owner.compareAndSet(current, null);
            }
        }
    }
}

public class ReentrantReadWriteLock
    implements ReadWriteLock, java.io.Serializable {
    private static final long serialVersionUID = -6992448646407690164L;

    // 讀鎖內(nèi)部類對(duì)象
    private final ReentrantReadWriteLock.ReadLock readerLock;

    // 寫鎖內(nèi)部類對(duì)象
    private final ReentrantReadWriteLock.WriteLock writerLock;

    // 執(zhí)行所有的同步機(jī)制
    final Sync sync;

    // 無參構(gòu)造函數(shù) 調(diào)用有參構(gòu)造 ReentrantReadWriteLock(boolean fair)
    public ReentrantReadWriteLock() {
        this(false);
    }

    // 有參構(gòu)造函數(shù) 是否創(chuàng)建公平鎖
    public ReentrantReadWriteLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
        readerLock = new ReadLock(this);
        writerLock = new WriteLock(this);
    }

    //  返回讀鎖和寫鎖的對(duì)象
    public ReentrantReadWriteLock.WriteLock writeLock() { return writerLock; }
    public ReentrantReadWriteLock.ReadLock  readLock()  { return readerLock; }

    // 繼承自 AbstractQueueSynchronizer 的Sync
    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 6317671515068378041L;

        // 共享移位
        static final int SHARED_SHIFT   = 16;
        // 共享單位
        static final int SHARED_UNIT    = (1 << SHARED_SHIFT);
        // 最大數(shù)量
        static final int MAX_COUNT      = (1 << SHARED_SHIFT) - 1;
        // 獨(dú)占
        static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;

        // 返回共享鎖的數(shù)量 
        static int sharedCount(int c)    { return c >>> SHARED_SHIFT; }
        // 返回獨(dú)占鎖的數(shù)量
        static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }

        // 每線程讀取保持計(jì)數(shù)的計(jì)數(shù)器
        static final class HoldCounter {
            int count = 0;
            // 使用id 而不是使用引用 避免垃圾殘留
            final long tid = getThreadId(Thread.currentThread());
        }

        // 線程本地子類
        static final class ThreadLocalHoldCounter
            extends ThreadLocal<HoldCounter> {
            public HoldCounter initialValue() {
                return new HoldCounter();
            }
        }

        // 當(dāng)前線程持有的可重入鎖的數(shù)量，只在構(gòu)造函數(shù)和readObject中初始化，
        // 當(dāng)線程的讀取保持計(jì)數(shù)下降到0的時(shí)候刪除
        private transient ThreadLocalHoldCounter readHolds;

        // 獲取readLock的最后一個(gè)線程的保持計(jì)數(shù)
        private transient HoldCounter cachedHoldCounter;

        // 第一個(gè)獲得讀的線程
        private transient Thread firstReader = null;
        // 計(jì)數(shù)器
        private transient int firstReaderHoldCount;

        Sync() {
            readHolds = new ThreadLocalHoldCounter();
            setState(getState()); // ensures visibility of readHolds
        }

        // 當(dāng)前線程獲取鎖的時(shí)候由于策略超過其他等待線程而應(yīng)阻止，返回true
        abstract boolean readerShouldBlock();

        // 如果由于試圖超越其他等待線程的策略而導(dǎo)致當(dāng)前線程在嘗試獲取寫鎖（且有資格這樣做）
        // 時(shí)應(yīng)阻塞，則返回true
        abstract boolean writerShouldBlock();

        // 嘗試釋放
        protected final boolean tryRelease(int releases) {
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            int nextc = getState() - releases;
            boolean free = exclusiveCount(nextc) == 0;
            if (free)
                setExclusiveOwnerThread(null);
            setState(nextc);
            return free;
        }

        // 嘗試增加
        protected final boolean tryAcquire(int acquires) {
            /*
             * Walkthrough:
             * 1. If read count nonzero or write count nonzero
             *    and owner is a different thread, fail.
             * 2. If count would saturate, fail. (This can only
             *    happen if count is already nonzero.)
             * 3. Otherwise, this thread is eligible for lock if
             *    it is either a reentrant acquire or
             *    queue policy allows it. If so, update state
             *    and set owner.
             */
            Thread current = Thread.currentThread();
            int c = getState();
            int w = exclusiveCount(c);
            if (c != 0) {
                // (Note: if c != 0 and w == 0 then shared count != 0)
                if (w == 0 || current != getExclusiveOwnerThread())
                    return false;
                if (w + exclusiveCount(acquires) > MAX_COUNT)
                    throw new Error("Maximum lock count exceeded");
                // Reentrant acquire
                setState(c + acquires);
                return true;
            }
            if (writerShouldBlock() ||
                !compareAndSetState(c, c + acquires))
                return false;
            setExclusiveOwnerThread(current);
            return true;
        }

        // 嘗試釋放共享鎖
        protected final boolean tryReleaseShared(int unused) {
            Thread current = Thread.currentThread();
            if (firstReader == current) {
                // assert firstReaderHoldCount > 0;
                if (firstReaderHoldCount == 1)
                    firstReader = null;
                else
                    firstReaderHoldCount--;
            } else {
                HoldCounter rh = cachedHoldCounter;
                if (rh == null || rh.tid != getThreadId(current))
                    rh = readHolds.get();
                int count = rh.count;
                if (count <= 1) {
                    readHolds.remove();
                    if (count <= 0)
                        throw unmatchedUnlockException();
                }
                --rh.count;
            }
            for (;;) {
                int c = getState();
                int nextc = c - SHARED_UNIT;
                if (compareAndSetState(c, nextc))
                    // Releasing the read lock has no effect on readers,
                    // but it may allow waiting writers to proceed if
                    // both read and write locks are now free.
                    return nextc == 0;
            }
        }

        // 非法的監(jiān)視器狀態(tài)異常
        private IllegalMonitorStateException unmatchedUnlockException() {
            return new IllegalMonitorStateException(
                "attempt to unlock read lock, not locked by current thread");
        }

        // 嘗試加共享鎖
        protected final int tryAcquireShared(int unused) {
            /*
             * Walkthrough:
             * 1. If write lock held by another thread, fail.
             * 2. Otherwise, this thread is eligible for
             *    lock wrt state, so ask if it should block
             *    because of queue policy. If not, try
             *    to grant by CASing state and updating count.
             *    Note that step does not check for reentrant
             *    acquires, which is postponed to full version
             *    to avoid having to check hold count in
             *    the more typical non-reentrant case.
             * 3. If step 2 fails either because thread
             *    apparently not eligible or CAS fails or count
             *    saturated, chain to version with full retry loop.
             */
            Thread current = Thread.currentThread();
            int c = getState();
            if (exclusiveCount(c) != 0 &&
                getExclusiveOwnerThread() != current)
                return -1;
            int r = sharedCount(c);
            if (!readerShouldBlock() &&
                r < MAX_COUNT &&
                compareAndSetState(c, c + SHARED_UNIT)) {
                if (r == 0) {
                    firstReader = current;
                    firstReaderHoldCount = 1;
                } else if (firstReader == current) {
                    firstReaderHoldCount++;
                } else {
                    HoldCounter rh = cachedHoldCounter;
                    if (rh == null || rh.tid != getThreadId(current))
                        cachedHoldCounter = rh = readHolds.get();
                    else if (rh.count == 0)
                        readHolds.set(rh);
                    rh.count++;
                }
                return 1;
            }
            return fullTryAcquireShared(current);
        }

        // 讀取的完整版本，可處理CAS丟失和tryAcquireShared中未處理的可重入讀取
        final int fullTryAcquireShared(Thread current) {

            HoldCounter rh = null;
            for (;;) {
                int c = getState();
                if (exclusiveCount(c) != 0) {
                    if (getExclusiveOwnerThread() != current)
                        return -1;

                } else if (readerShouldBlock()) {

                    if (firstReader == current) {
                        // assert firstReaderHoldCount > 0;
                    } else {
                        if (rh == null) {
                            rh = cachedHoldCounter;
                            if (rh == null || rh.tid != getThreadId(current)) {
                                rh = readHolds.get();
                                if (rh.count == 0)
                                    readHolds.remove();
                            }
                        }
                        if (rh.count == 0)
                            return -1;
                    }
                }
                if (sharedCount(c) == MAX_COUNT)
                    throw new Error("Maximum lock count exceeded");
                if (compareAndSetState(c, c + SHARED_UNIT)) {
                    if (sharedCount(c) == 0) {
                        firstReader = current;
                        firstReaderHoldCount = 1;
                    } else if (firstReader == current) {
                        firstReaderHoldCount++;
                    } else {
                        if (rh == null)
                            rh = cachedHoldCounter;
                        if (rh == null || rh.tid != getThreadId(current))
                            rh = readHolds.get();
                        else if (rh.count == 0)
                            readHolds.set(rh);
                        rh.count++;
                        cachedHoldCounter = rh; // cache for release
                    }
                    return 1;
                }
            }
        }

        // 執(zhí)行tryLock進(jìn)行寫入，從而在兩種模式下都可以進(jìn)行插入，這與tryAcquire的作用相同
        // 只是缺少對(duì) writerShouldBlock的調(diào)用
        final boolean tryWriteLock() {
            Thread current = Thread.currentThread();
            int c = getState();
            if (c != 0) {
                int w = exclusiveCount(c);
                if (w == 0 || current != getExclusiveOwnerThread())
                    return false;
                if (w == MAX_COUNT)
                    throw new Error("Maximum lock count exceeded");
            }
            if (!compareAndSetState(c, c + 1))
                return false;
            setExclusiveOwnerThread(current);
            return true;
        }

        // 執(zhí)行tryLock進(jìn)行讀取，從而在兩種模式下都可以進(jìn)行插入。 
        // 除了沒有調(diào)用readerReaderShouldBlock以外，這與tryAcquireShared的作用相同。
        final boolean tryReadLock() {
            Thread current = Thread.currentThread();
            for (;;) {
                int c = getState();
                if (exclusiveCount(c) != 0 &&
                    getExclusiveOwnerThread() != current)
                    return false;
                int r = sharedCount(c);
                if (r == MAX_COUNT)
                    throw new Error("Maximum lock count exceeded");
                if (compareAndSetState(c, c + SHARED_UNIT)) {
                    if (r == 0) {
                        firstReader = current;
                        firstReaderHoldCount = 1;
                    } else if (firstReader == current) {
                        firstReaderHoldCount++;
                    } else {
                        HoldCounter rh = cachedHoldCounter;
                        if (rh == null || rh.tid != getThreadId(current))
                            cachedHoldCounter = rh = readHolds.get();
                        else if (rh.count == 0)
                            readHolds.set(rh);
                        rh.count++;
                    }
                    return true;
                }
            }
        }

        // 是否獨(dú)占鎖
        protected final boolean isHeldExclusively() {
            return getExclusiveOwnerThread() == Thread.currentThread();
        }

        // 返回Condition對(duì)象
        final ConditionObject newCondition() {
            return new ConditionObject();
        }

        // 返回獨(dú)占鎖
        final Thread getOwner() {
            return ((exclusiveCount(getState()) == 0) ?
                    null :
                    getExclusiveOwnerThread());
        }

        // 獲取readLock所得個(gè)數(shù)
        final int getReadLockCount() {
            return sharedCount(getState());
        }

        // 判斷是否是 writeLock 鎖
        final boolean isWriteLocked() {
            return exclusiveCount(getState()) != 0;
        }

        // 獲得寫鎖的數(shù)量
        final int getWriteHoldCount() {
            return isHeldExclusively() ? exclusiveCount(getState()) : 0;
        }

        // 獲得讀鎖的數(shù)量
        final int getReadHoldCount() {
            if (getReadLockCount() == 0)
                return 0;

            Thread current = Thread.currentThread();
            if (firstReader == current)
                return firstReaderHoldCount;

            HoldCounter rh = cachedHoldCounter;
            if (rh != null && rh.tid == getThreadId(current))
                return rh.count;

            int count = readHolds.get().count;
            if (count == 0) readHolds.remove();
            return count;
        }

        // 序列化
        private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {
            s.defaultReadObject();
            readHolds = new ThreadLocalHoldCounter();
            setState(0); // reset to unlocked state
        }

        // 獲取數(shù)量
        final int getCount() { return getState(); }
    }

    // 非公平鎖
    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = -8159625535654395037L;
        final boolean writerShouldBlock() {
            return false; // writers can always barge
        }
        final boolean readerShouldBlock() {
            return apparentlyFirstQueuedIsExclusive();
        }
    }

    // 公平鎖
    static final class FairSync extends Sync {
        private static final long serialVersionUID = -2274990926593161451L;
        final boolean writerShouldBlock() {
            return hasQueuedPredecessors();
        }
        final boolean readerShouldBlock() {
            return hasQueuedPredecessors();
        }
    }

    // 讀鎖實(shí)現(xiàn)了 Lock 接口
    public static class ReadLock implements Lock, java.io.Serializable {
        private static final long serialVersionUID = -5992448646407690164L;
        private final Sync sync;

        // 初始化，獲得是否是公平讀鎖
        protected ReadLock(ReentrantReadWriteLock lock) {
            sync = lock.sync;
        }

        // 加鎖 是共享鎖
        public void lock() {
            sync.acquireShared(1);
        }

        // 鎖中斷
        public void lockInterruptibly() throws InterruptedException {
            sync.acquireSharedInterruptibly(1);
        }

        // 調(diào)用加鎖
        public boolean tryLock() {
            return sync.tryReadLock();
        }

        // 超時(shí)加鎖
        public boolean tryLock(long timeout, TimeUnit unit)
            throws InterruptedException {
            return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
        }

        // 解鎖
        public void unlock() {
            sync.releaseShared(1);
        }

        // Condition 對(duì)象
        public Condition newCondition() {
            throw new UnsupportedOperationException();
        }

        // toString方法
        public String toString() {
            int r = sync.getReadLockCount();
            return super.toString() +
                "[Read locks = " + r + "]";
        }
    }

    // 寫鎖
    public static class WriteLock implements Lock, java.io.Serializable {
        private static final long serialVersionUID = -4992448646407690164L;
        private final Sync sync;

        // 寫鎖初始化
        protected WriteLock(ReentrantReadWriteLock lock) {
            sync = lock.sync;
        }

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

        // 鎖中斷
        public void lockInterruptibly() throws InterruptedException {
            sync.acquireInterruptibly(1);
        }

        // 加鎖
        public boolean tryLock( ) {
            return sync.tryWriteLock();
        }

        // 超時(shí)加鎖
        public boolean tryLock(long timeout, TimeUnit unit)
            throws InterruptedException {
            return sync.tryAcquireNanos(1, unit.toNanos(timeout));
        }

        // 解鎖，調(diào)用 release 減1
        public void unlock() {
            sync.release(1);
        }

        // Condition對(duì)象
        public Condition newCondition() {
            return sync.newCondition();
        }

        // toString方法
        public String toString() {
            Thread o = sync.getOwner();
            return super.toString() + ((o == null) ?
                                       "[Unlocked]" :
                                       "[Locked by thread " + o.getName() + "]");
        }

        // 是否有獨(dú)占的線程
        public boolean isHeldByCurrentThread() {
            return sync.isHeldExclusively();
        }

        // 獲取寫鎖的數(shù)量
        public int getHoldCount() {
            return sync.getWriteHoldCount();
        }
    }

    // 判斷是否是公平鎖
    public final boolean isFair() {
        return sync instanceof FairSync;
    }

    // 判斷是否是獨(dú)占鎖
    protected Thread getOwner() {
        return sync.getOwner();
    }

    // 獲取讀鎖的個(gè)數(shù)
    public int getReadLockCount() {
        return sync.getReadLockCount();
    }

    // 判斷是否是寫鎖
    public boolean isWriteLocked() {
        return sync.isWriteLocked();
    }

    // 判斷鎖是否被當(dāng)前線程持有
    public boolean isWriteLockedByCurrentThread() {
        return sync.isHeldExclusively();
    }

    // 查詢當(dāng)前線程對(duì)該鎖的可重入寫入次數(shù)
    public int getWriteHoldCount() {
        return sync.getWriteHoldCount();
    }

    // 查詢當(dāng)前線程對(duì)該鎖的可重讀次數(shù)
    public int getReadHoldCount() {
        return sync.getReadHoldCount();
    }

    // 返回寫線程的集合
    protected Collection<Thread> getQueuedWriterThreads() {
        return sync.getExclusiveQueuedThreads();
    }

    // 返回讀線程的集合
    protected Collection<Thread> getQueuedReaderThreads() {
        return sync.getSharedQueuedThreads();
    }

    // 查詢是否有任何線程正在等待獲取讀或?qū)戞i
    public final boolean hasQueuedThreads() {
        return sync.hasQueuedThreads();
    }

    //  查詢指定線程是否在等待讀或者寫鎖
    public final boolean hasQueuedThread(Thread thread) {
        return sync.isQueued(thread);
    }

    // 獲取等待隊(duì)列的長度
    public final int getQueueLength() {
        return sync.getQueueLength();
    }

    // 獲得等待隊(duì)列中的線程集合
    protected Collection<Thread> getQueuedThreads() {
        return sync.getQueuedThreads();
    }

    // 查詢是否有任何線程正在等待與寫鎖關(guān)聯(lián)的給定條件
    public boolean hasWaiters(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync.hasWaiters((AbstractQueuedSynchronizer.ConditionObject)condition);
    }

    // 查詢是否有任何線程正在等待與寫鎖關(guān)聯(lián)的給定條件的長度
    public int getWaitQueueLength(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync.getWaitQueueLength((AbstractQueuedSynchronizer.ConditionObject)condition);
    }

    // 獲得給定條件等待線程的集合
    protected Collection<Thread> getWaitingThreads(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync.getWaitingThreads((AbstractQueuedSynchronizer.ConditionObject)condition);
    }

    // toString()方法
    public String toString() {
        int c = sync.getCount();
        int w = Sync.exclusiveCount(c);
        int r = Sync.sharedCount(c);

        return super.toString() +
            "[Write locks = " + w + ", Read locks = " + r + "]";
    }

    // 獲取線程ID
    static final long getThreadId(Thread thread) {
        return UNSAFE.getLongVolatile(thread, TID_OFFSET);
    }

    // Unsafe對(duì)象
    private static final sun.misc.Unsafe UNSAFE;
    private static final long TID_OFFSET;
    static {
        try {
            UNSAFE = sun.misc.Unsafe.getUnsafe();
            Class<?> tk = Thread.class;
            TID_OFFSET = UNSAFE.objectFieldOffset
                (tk.getDeclaredField("tid"));
        } catch (Exception e) {
            throw new Error(e);
        }
    }
}

@Override
public synchronized StringBuffer append(String str) {
    toStringCache = null;
    super.append(str);
    return this;
}

public class Demo {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        int size = 10000;
        for (int i = 0; i < size; i++) {
            createStringBuffer("ic", "java");
        }
        long timeCost = System.currentTimeMillis() - start;
        System.out.println("createStringBuffer:" + timeCost + " ms");
    }
    public static String createStringBuffer(String str1, String str2) {
        StringBuffer sBuf = new StringBuffer();
        // append方法是同步操作
        sBuf.append(str1);
        sBuf.append(str2);
        return sBuf.toString();
    }
}

public class Semaphore implements java.io.Serializable {
    private static final long serialVersionUID = -3222578661600680210L;

    // Sync鎖
    private final Sync sync;

    // Sync實(shí)現(xiàn)了AbstractQueueSynchronizer
    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 1192457210091910933L;

        //  初始化版本初始值
        Sync(int permits) {
            setState(permits);
        }

        // 獲取狀態(tài)
        final int getPermits() {
            return getState();
        }

        // 不公平嘗試共享
        final int nonfairTryAcquireShared(int acquires) {
            for (;;) {
                int available = getState();
                int remaining = available - acquires;
                if (remaining < 0 ||
                    compareAndSetState(available, remaining))
                    return remaining;
            }
        }

        // 嘗試釋放共享
        protected final boolean tryReleaseShared(int releases) {
            for (;;) {
                int current = getState();
                int next = current + releases;
                if (next < current) // overflow
                    throw new Error("Maximum permit count exceeded");
                if (compareAndSetState(current, next))
                    return true;
            }
        }

        // 減少狀態(tài)的指定值
        final void reducePermits(int reductions) {
            for (;;) {
                int current = getState();
                int next = current - reductions;
                if (next > current) // underflow
                    throw new Error("Permit count underflow");
                if (compareAndSetState(current, next))
                    return;
            }
        }

        final int drainPermits() {
            for (;;) {
                int current = getState();
                if (current == 0 || compareAndSetState(current, 0))
                    return current;
            }
        }
    }

    // 非公平鎖
    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = -2694183684443567898L;

        NonfairSync(int permits) {
            super(permits);
        }

        protected int tryAcquireShared(int acquires) {
            return nonfairTryAcquireShared(acquires);
        }
    }

    // 公平鎖
    static final class FairSync extends Sync {
        private static final long serialVersionUID = 2014338818796000944L;

        FairSync(int permits) {
            super(permits);
        }

        protected int tryAcquireShared(int acquires) {
            for (;;) {
                if (hasQueuedPredecessors())
                    return -1;
                int available = getState();
                int remaining = available - acquires;
                if (remaining < 0 ||
                    compareAndSetState(available, remaining))
                    return remaining;
            }
        }
    }

    // 構(gòu)造方法 設(shè)置初始版本號(hào)
    public Semaphore(int permits) {
        sync = new NonfairSync(permits);
    }

    // 構(gòu)造方法
    public Semaphore(int permits, boolean fair) {
        sync = fair ? new FairSync(permits) : new NonfairSync(permits);
    }

    // 增加1
    public void acquire() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

    // 不間斷地獲取
    public void acquireUninterruptibly() {
        sync.acquireShared(1);
    }

    // 從此信號(hào)量獲取許可，直到獲得一個(gè)許可為止，將一直阻塞
    public void acquireUninterruptibly() {
        sync.acquireShared(1);
    }

    // 僅在調(diào)用時(shí)可用時(shí)，才從此信號(hào)量獲取許可
    public boolean tryAcquire() {
        return sync.nonfairTryAcquireShared(1) >= 0;
    }

    // 定時(shí)設(shè)置
    public boolean tryAcquire(long timeout, TimeUnit unit)
        throws InterruptedException {
        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
    }

    // 釋放
    public void release() {
        sync.releaseShared(1);
    }

    // 設(shè)置指定的個(gè)數(shù)
    public void acquire(int permits) throws InterruptedException {
        if (permits < 0) throw new IllegalArgumentException();
        sync.acquireSharedInterruptibly(permits);
    }

    // 獲得許可證的給定數(shù)目從這個(gè)信號(hào)，阻塞直到所有可用。
    public void acquireUninterruptibly(int permits) {
        if (permits < 0) throw new IllegalArgumentException();
        sync.acquireShared(permits);
    }

    // 獲得許可證的給定數(shù)目從此信號(hào)量，只有在所有可在調(diào)用的時(shí)候。
    public boolean tryAcquire(int permits) {
        if (permits < 0) throw new IllegalArgumentException();
        return sync.nonfairTryAcquireShared(permits) >= 0;
    }

    // 收購從此信號(hào)量許可證的給定數(shù)量，如果所有給定的等待時(shí)間內(nèi)變得可用，并且當(dāng)前線程未被中斷 
    public boolean tryAcquire(int permits, long timeout, TimeUnit unit)
        throws InterruptedException {
        if (permits < 0) throw new IllegalArgumentException();
        return sync.tryAcquireSharedNanos(permits, unit.toNanos(timeout));
    }

    // 釋放
    public void release(int permits) {
        if (permits < 0) throw new IllegalArgumentException();
        sync.releaseShared(permits);
    }

    // 返回現(xiàn)在的剩余值
    public int availablePermits() {
        return sync.getPermits();
    }

    // 返回減少之后的值
    public int drainPermits() {
        return sync.drainPermits();
    }

    // 減少指定個(gè)數(shù)的值
    protected void reducePermits(int reduction) {
        if (reduction < 0) throw new IllegalArgumentException();
        sync.reducePermits(reduction);
    }

    // 判斷是否時(shí)公平鎖
    public boolean isFair() {
        return sync instanceof FairSync;
    }

    // 判斷隊(duì)列是否有線程 
    public final boolean hasQueuedThreads() {
        return sync.hasQueuedThreads();
    }

    // 返回線程的長度
    public final int getQueueLength() {
        return sync.getQueueLength();
    }

    // 返回隊(duì)列線程的集合
    protected Collection<Thread> getQueuedThreads() {
        return sync.getQueuedThreads();
    }

    // toString() 方法
    public String toString() {
        return super.toString() + "[Permits = " + sync.getPermits() + "]";
    }
}

// 它默認(rèn)是非公平鎖
public ReentrantLock() {
    sync = new NonfairSync();
}

// 創(chuàng)建ReentrantLock，公平鎖or非公平鎖
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

// 而他會(huì)分別調(diào)用lock方法和unlock方法來釋放鎖
public void lock() {
    sync.lock();
}

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

public class DeadLockDemo {
    public static void main(String[] args) {
        String lockA = "lockA";
        String lockB = "lockB";
        MyThread myThread1 = new MyThread(lockA,lockB);
        MyThread myThread2 = new MyThread(lockB,lockA);
        new Thread(myThread1).start();
        new Thread(myThread2).start();
    }

}

class MyThread implements Runnable {

    private String lockA;
    private String lockB;

    public MyThread(String lockA, String lockB) {
        this.lockA = lockA;
        this.lockB = lockB;
    }

    @Override
    public void run() {
        synchronized (lockA) {
            System.out.println(Thread.currentThread().getName() + "lock：" + lockA + " => " + lockB);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lockB) {
                System.out.println(Thread.currentThread().getName() + "lock：" + lockB + " => " + lockA);
            }
        }
    }
}