ReentrantLock源码解析

 

ReentrantLock简介：重入锁ReetrantLock，实现了Lock接口，作用与synchronized关键字相当，但比synchronized更加灵活。ReetrantLock本身也是一种支持重进入的锁，即该锁可以支持一个线程对资源重复加锁，同时也支持公平锁与非公平锁。所谓的公平与非公平指的是在请求先后顺序上，先对锁进行请求的就一定先获取到锁，那么这就是公平锁，反之，如果对于锁的获取并没有时间上的先后顺序，如后请求的线程可能先获取到锁，这就是非公平锁，一般而言非，非公平锁机制的效率往往会胜过公平锁的机制，但在某些场景下，可能更注重时间先后顺序，那么公平锁自然是很好的选择。需要注意的是ReetrantLock支持对同一线程重加锁，但是加锁多少次，就必须解锁多少次，这样才可以成功释放锁。

 

ReentrantLock实现了Lock接口。但是底层锁机制是通过AQS实现的。ReentrantLock有一个内部类Sync是继承了AQS 源码如下

abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;

        //锁对象
        abstract void lock();

        //非公平锁获取锁资源
        final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

        protected final boolean isHeldExclusively() {
            // While we must in general read state before owner,
            // we don't need to do so to check if current thread is owner
            return getExclusiveOwnerThread() == Thread.currentThread();
        }

        final ConditionObject newCondition() {
            return new ConditionObject();
        }

        // Methods relayed from outer class

        final Thread getOwner() {
            return getState() == 0 ? null : getExclusiveOwnerThread();
        }

        final int getHoldCount() {
            return isHeldExclusively() ? getState() : 0;
        }

        final boolean isLocked() {
            return getState() != 0;
        }

        /**
         * Reconstitutes the instance from a stream (that is, deserializes it).
         */
        private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {
            s.defaultReadObject();
            setState(0); // reset to unlocked state
        }
    }

 非公平锁NonfairSync的实现

在ReentrantLock还有两个内部类其中一个就是NonfairSync他继承了抽象类Sync 

  static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;
        
        //非公平锁的具体实现
        final void lock() {
            // CAS比较state变量值 去更改state的值为1 尝试去获取锁
            if (compareAndSetState(0, 1))
                //获取锁成功。成功则将独占锁线程设置为当前线程  
                setExclusiveOwnerThread(Thread.currentThread());
            else
                // 失败的情况下、 再次请求同步状态
                acquire(1);
        }

        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }

    //AQS 中的方法 尝试获取锁
    public final void acquire(int arg) {
         // tryAcquire(arg) 获取锁成功为true 否则为false
        if (!tryAcquire(arg) &&
            // addWaiter 在同步队列中的队尾新增一条数据
   
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))

             
            selfInterrupt();
    }

    //AQS 中的方法 尝试获取锁
    final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            一直循环
            for (;;) {
                  // 获取当前节点的前置节点
                final Node p = node.predecessor();
                
                if (p == head && tryAcquire(arg)) {
                     //获取前置节点为头部节点，并且头部节点已经获取锁了
                     // 设置头部节点为当前接口
                    setHead(node);
                    // 并将已经获取锁的节点的后驱节点置为null 便于垃圾回收
                    p.next = null;
                    failed = false;
                    return interrupted;
                }
                //响应中断 判断当前节点的前置节点是否为头部接口并且当前节点的线程是否被中断 
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            //获取锁失败。那么就会取消获取锁。将node节点的状态置为cancel取消状态
            if (failed)
                cancelAcquire(node);
        }
    }


acquire具体的实现逻辑在sync的nonfairTryAcquire方法
         final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            // 尝试获取state状态
            int c = getState();
            // 如果state 说明资源没有被占用
            if (c == 0) {
                //CAS成功后变获取锁、
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
             //如果资源被占用，并且被占用的线程是当前线程那么state++
            else if (current == getExclusiveOwnerThread()) {
                 //如果资源被占用
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

 公平锁NonfairSync的实现

 static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;

        final void lock() {
            acquire(1);
        }

         
       // 公平锁获取资源的方式 与非公平说最大的区别在
         // hasQueuedPredecessors方法
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }

// 按照严格的队列的FIFO的规则进行 只有当前前程是头部node 头部node的线程信息是当前线程才能获取锁
public final boolean hasQueuedPredecessors() {
        // The correctness of this depends on head being initialized
        // before tail and on head.next being accurate if the current
        // thread is first in queue.
        Node t = tail; // Read fields in reverse initialization order
        Node h = head;
        Node s;
        return h != t &&
            ((s = h.next) == null || s.thread != Thread.currentThread());
    }

解锁的过程

 

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

    public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }