static Lock lock = new ReentrantLock();
public static void main(String[] args) throws InterruptedException {         lock.lock();//其他沒(méi)拿到鎖的卡住不動(dòng)         Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("start to get lock Interruptibly");
                lock.unlock(); //看看會(huì)發(fā)生什么，注釋掉再看看
                lock.lock();
                System.out.println("拿到鎖");
                lock.unlock();
                System.out.println("釋放鎖");
            }
        });
        thread.start();         Thread.sleep(3000);
        lock.unlock();
    }

public class MyLock implements Lock {
    //多并發(fā)調(diào)用  0-未占用 大于0-占用
    AtomicInteger state = new AtomicInteger();     Thread ownerThread = new Thread();     //等待鎖的隊(duì)列
    LinkedBlockingQueue<Thread> waiters = new LinkedBlockingQueue();     @Override
    public void lock() {
        if (!tryLock()) {  //先搶鎖，所以是非公平鎖
            //沒(méi)拿到鎖,放到隊(duì)列中去進(jìn)行排隊(duì)
            waiters.add(Thread.currentThread());
            //等待被喚醒
            for (; ; ) {
                if (tryLock()) {  //非公平鎖情況下，喚醒過(guò)來(lái)繼續(xù)獲取鎖
                    waiters.poll(); //獲取鎖成功把自己從隊(duì)列中取出來(lái)
                    return;
                } else    //獲取鎖失敗
                    LockSupport.park();  //線程阻塞
            }
        }
    }     @Override
    public boolean tryLock() {
        if (state.get() == 0) { //如果鎖沒(méi)被占用
            if (state.compareAndSet(0, 1)) {  //如果成功拿到鎖
                ownerThread = Thread.currentThread();   //占用鎖線程改為當(dāng)前線程
                return true;
            }
        }
        return false;
    }     @Override
    public void unlock() {         if (ownerThread != Thread.currentThread())  //占用鎖線程不是當(dāng)前線程無(wú)法釋放鎖
            throw new RuntimeException("非法調(diào)用,當(dāng)前鎖不屬于你");         if (state.decrementAndGet() == 0)  //如果成功釋放鎖
            ownerThread = null;  //占用鎖線程置空
        //通知其他線程
//        Thread thread = null;
//
//        while ((thread = waiters.peek()) != null)
//            LockSupport.unpark(thread);
        Thread thread = waiters.peek(); //獲取隊(duì)列頭部線程，線程還留在隊(duì)列中
        if (thread != null) {
            LockSupport.unpark(thread); //取消阻塞
        }
    }     @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return false;
    }     @Override
    public Condition newCondition() {
        return null;
    }     @Override
    public void lockInterruptibly() throws InterruptedException {     }
}

  @Override
    public void lock() {
       checkQueue（）;//線程來(lái)的時(shí)候先不獲取鎖，而是先檢查隊(duì)列中有沒(méi)有等待的線程，如果有，直接放入隊(duì)列，如果沒(méi)有，再去獲取鎖
        if (!tryLock()) {  //先搶鎖，所以是非公平鎖
            //沒(méi)拿到鎖,放到隊(duì)列中去進(jìn)行排隊(duì)
            waiters.add(Thread.currentThread());
            //等待被喚醒
            for (; ; ) {
                if (tryLock()) {  //非公平鎖情況下，喚醒過(guò)來(lái)繼續(xù)獲取鎖
                    waiters.poll(); //獲取鎖成功把自己從隊(duì)列中取出來(lái)
                    return;
                } else    //獲取鎖失敗
                    LockSupport.park();  //線程阻塞
            }
        }
    }

public interface Lock {
    // 加鎖
    void lock()；
    // 嘗試獲取鎖
    boolean tryLock();
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    // 解鎖
    void unlock();
}

    // 默認(rèn)構(gòu)造方法，非公平鎖
    public ReentrantLock() {
        sync = new NonfairSync();
    }
    // 構(gòu)造方法，公平鎖
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }
    // 加鎖
    public void lock() {
        sync.lock();
    }