JUC源码阅读之ReentrantLock-AQS独占模式的典型实现

ReentrantLock是一个可以重入的互斥(独占)锁,支持公平锁和不公平锁(默认)。他的内部实现主要是有一个Sync内部类,具体情况我们注意阅读源码进行分析。

1.Sync

Sync是一个实现了AQS的内部类,他还有FairSync和NonFairSync两种实现。Sync是这个锁的基础,使用了AQS中的state来表示当前拥有的锁的数量(因为是重入锁,可能被多次lock)。

  

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

        /**
         * Performs {@link Lock#lock}. The main reason for subclassing
         * is to allow fast path for nonfair version.
         */
        abstract void lock();

        /**
         * Performs non-fair tryLock.  tryAcquire is implemented in
         * subclasses, but both need nonfair try for trylock method.
		 *执行非公平的tryLock,tryAcquire是在子类中实现的,但是都需要nonfair来尝试
         */
        final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();//获取当前状态,AQS方法
            if (c == 0) {
				//如果state为0,表示锁没有被获取,则尝试获取锁(用CAS设置State)
				//获取成功就设置拥有锁的线程为当前线程
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }//如果state不为0(锁未被释放),如果当前线程就是获取锁的线程,那么就再设置一次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;
        }

        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
			//如果当前线程不是拥有锁的线程,就抛出异常
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
			//如果本次release之后,state为0,就将拥有锁的线程设置为null。
			//否则就是设置state为新的值。
            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
		//如果没有线程拥有锁(state为0)就返回null,否则返回拥有锁的线程
        final Thread getOwner() {
            return getState() == 0 ? null : getExclusiveOwnerThread();
        }
		//返回当前锁的重入的数量
        final int getHoldCount() {
            return isHeldExclusively() ? getState() : 0;
        }
		//state不为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
        }
    }
非公平锁

    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        /**
         * Performs lock.  Try immediate barge, backing up to normal
         * acquire on failure.
         */
		//设置状态为1,如果失败就调用AQS的acquire,
		//acquire的实现就是先tryAcquire(也就是紧接下面的方法),不成功再入队等待
        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }
		//调用Sync里面的方法,当前获取锁的是本线程,就重入,否则就返回false
        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }
公平锁

    static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;
		
		//直接调用acquire(1),非公平是自己先尝试获得锁,获得不了再acquire
		//他的acquire中tryAcquire是公平版本的实现
        final void lock() {
            acquire(1);
        }

        /**
         * Fair version of tryAcquire.  Don't grant access unless
         * recursive call or no waiters or is first.
         */
		 //公平版本的tryAcquire,只有在递归调用,或者没有其他等待者或者自己是第一的时候获取锁
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
			//如果state为0(没有锁),hasQueuedPredecessors()判断自己是不是等待最久的(AQS方法)
			//如果是等待最久的,就尝试设置state,设置成功了就表明拥有了锁。
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }//state不为0,就查看是不是当前线程拥有锁,是的话就重入锁
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }

2.Lock中的一些方法

构造函数,不带参数就是非公平锁,带参数,true就是公平锁,

    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }
public 方法,lock就是尝试获取锁,调用内部类的方法
    public void lock() {
        sync.lock();
    }
	 //以响应中断的模式获取锁,先调用AQS的acquireInterruptibly()方法,
	 //这个方法中会调用子类的tryAcquire()方法,如果失败,再入队等待锁
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }
tryLock(),获取锁失败(设置state失败或者当前已经有线程拥有锁),就返回false,而不是入队等待

    public boolean tryLock() {
        return sync.nonfairTryAcquire(1);
    }
unLock()释放锁

	//release是AQS的方法,先调用子类的tryRelease(),然后在唤醒队列中的后继节点
    public void unlock() {
        sync.release(1);
    }

这就是ReentrantLock的基本实现,可以看到,除了自己完成了几个模板方法(对state进行判断),其他基本都是调用AQS的方法。

Condition就完全没有自己实现,完全依赖AQS的实现。





  

你可能感兴趣的:(java源码阅读)