ReentrantLock 详解

ReentrantLock 介绍

• ReentrantLock是一个可重入的互斥锁，又被称为“独占锁”。
• ReentrantLock锁在同一个时间点只能被一个线程锁持有；可重入表示，ReentrantLock锁可以被同一个线程多次获取。
• ReentraantLock是通过一个FIFO的等待队列来管理获取该锁所有线程的。在“公平锁”的机制下，线程依次排队获取锁；而“非公平锁”在锁是可获取状态时，不管自己是不是在队列的开头都会获取锁。

ReentrantLock构造方法

   /**
     * 默认创建非公平锁
     */
    public ReentrantLock() {
   
        sync = new NonfairSync();
    }

    /**
     * fair为true表示是公平锁，fair为false表示是非公平锁
     */
    public ReentrantLock(boolean fair) {
   
        sync = fair ? new FairSync() : new NonfairSync();
    }

ReentrantLock核心方法

   /**
     * 阻塞等待获取锁;不允许Thread.interrupt中断,即使检测到Thread.isInterrupted,一样会继续尝试      * 获取锁，失败则继续休眠。只是在最后获取锁成功后再把当前线程置为interrupted状态,然后再中断线程。
     */
    public void lock() {
   
        sync.lock();
    }

    /**
     * 当前线程未被中断，则获取锁
     * 允许在等待时由其它线程调用等待线程的Thread.interrupt方法来中断等待线程的等待而直接返回，这时      * 不用获取锁，而会抛出一个InterruptedException
     */
    public void lockInterruptibly() throws InterruptedException {
   
        sync.acquireInterruptibly(1);
    }

    /**
     *尝试申请一个锁，在成功获得锁后返回true，否则，立即返回false
     */
    public boolean tryLock() {
   
        return sync.nonfairTryAcquire(1);
    }

    /**
     * 在一段时间内尝试申请一个锁，在成功获得锁后返回true，否则，立即返回false
     */
    public boolean tryLock(long timeout, TimeUnit unit)
            throws InterruptedException {
   
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }

    /**
     * 释放锁
     */
    public void unlock() {
   
        sync.release(1);
    }

    /**
     * 条件实例
     */
    public Condition newCondition() {
   
        return sync.newCondition();
    }

    /**
     * 获取当前线程持有此锁的次数
     */
    public int getHoldCount() {
   
        return sync.getHoldCount();
    }

    /**
     * 是否被当前线程持有
     */
    public boolean isHeldByCurrentThread() {
   
        return sync.isHeldExclusively();
    }

    /**
     * 查询此锁是否由任意线程持有
     */
    public boolean isLocked() {
   
        return sync.isLocked();
    }

    /**
     *如果是“公平锁”返回true，否则返回false
     */
    public final boolean isFair() {
   
        return sync instanceof FairSync;
    }

    /**
     * 获取目前拥有此锁的线程，如果此锁不被任何线程拥有，则返回 null
     */
    protected Thread getOwner() {
   
        return sync.getOwner();
    }

    /**
     * 查询是否有线程正在等待
     */
    public final boolean hasQueuedThreads() {
   
        return sync.hasQueuedThreads();
    }

    /**
     *查询给定线程是否正在等待获取此锁。
     */
    public final boolean hasQueuedThread(Thread thread) {
   
        return sync.isQueued(thread);
    }

    /**
     * 获取正等待获取此锁的线程数
     */
    public final int g