实战Java高并发程序设计之ReentrantLock(二)

前面讲到了ReentranLock的基本使用,现在来看看它的底层实现.

先看ReentrantLok的UML类图(图片来自:http://www.cnblogs.com/skywang12345/p/3496147.html)

ReentrantLock实现了Lock接口.内部维持着一个Sync对象.

    /**
     * 该锁基于同步控制. 分为公平锁和非公平锁. 
     * 使用AQS状态来表示锁上的保留数量.0表示无锁
     */
    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;

        //抽象的lock方法,交给子类去实现
        abstract void lock();

        /**
         * 执行不公平的tryLock.  tryAcquire在子类中实现, 都需要不公平锁去尝试tryLock()
         */
        final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            //获取当前同步的状态值
            int c = getState();
            //0表示该锁处于可获取状态
            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;
            //状态为0时,表示无锁
            if (c == 0) {
                free = true;
                //设置独占锁线程为空
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }
        
        /**
         * 判断当前线程是否被当前独占锁持有
         */
        protected final boolean isHeldExclusively() {
            return getExclusiveOwnerThread() == Thread.currentThread();
        }

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

        // 外部类传递的方法
        
        /**
         * 获取独占锁持有的线程
         */
        final Thread getOwner() {
        	//状态为0表示没有锁,返回空.
            return getState() == 0 ? null : getExclusiveOwnerThread();
        }
        
        /**
         * 获取锁的数量
         */
        final int getHoldCount() {
            return isHeldExclusively() ? getState() : 0;
        }
        
        /**
         * 判断是否被锁
         */
        final boolean isLocked() {
        	//状态不为0表示有锁
            return getState() != 0;
        }

        /**
         * 从流重构实例（即反序列化）.
         */
        private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {
            s.defaultReadObject();
            setState(0); // 重置无锁状态
        }
    }

FairSync和NonFairSync分别继承了Sync类,下面来看看它们的分别实现

/**
     * 非公平锁
     */
    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        /**
         * 非公平锁的lock会无视等待队列,直接去尝试获取锁,不成功则在调用acquire()尝试获取锁
         */
        final void lock() {
        	//如果AQS的状态为0,则将状态变为1,表示获得一把锁.然后设置独占锁所持有的线程为当前线程
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }
        
        /**
         * 尝试获取锁
         */
        protected final boolean tryAcquire(int acquires) {
        	//调用Sync的nonfairTryAcquire(args)方法
            return nonfairTryAcquire(acquires);
        }
    }

    /**
     * 公平锁
     */
    static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;
        
        /**
         * 获取一把锁
         */
        final void lock() {
            acquire(1);
        }

        /**
         * 去尝试获取锁，获取成功则设置锁状态并返回true，否则返回false
         */
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
            	//hasQueuedPredecessors()方法是查询队列中是否有比当前线程等待更长时间的线程
                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;
        }
    }

可以看出公平锁和非公平尝试获取锁的不同之处就体现在if(c == 0 )中

	// -----非公平锁-----
	if(c==0){
		if (compareAndSetState(0, acquires)) {
			etExclusiveOwnerThread(current);
			return true;
		}
	}
	// -------公平锁-----
	if(c==0){  
         if (!hasQueuedPredecessors() &&  
              compareAndSetState(0, acquires)) {  
              setExclusiveOwnerThread(current);  
              return true;  
	      }  
	  }

ReentrantLock类的其他方法:

	/**
	 * 无参构造
	 */
	public ReentrantLock() {
		sync = new NonfairSync();
	}

	/**
	 * 构建公平锁或非公平锁
	 */
	public ReentrantLock(boolean fair) {
		sync = fair ? new FairSync() : new NonfairSync();
	}

	/**
	 * 获取锁:如果锁没有被另一个线程占用并且立即返回，则将锁定计数设置为1
	 * 如果当前线程已经保持锁定，则保持计数增加1，该方法立即返回。
	 * 如果锁被另一个线程保持，则当前线程将被禁用以进行线程调度，并处于休眠状态，直到锁定被获取为止，此时锁定保持计数被设置为1.
	 */
	public void lock() {
		sync.lock();
	}

	/**
	 * 获取锁,除非当前线程中断
	 */
	public void lockInterruptibly() throws InterruptedException {
		sync.acquireInterruptibly(1);
	}

	/**
	 * 如果没有被另一个线程占用，则获取该锁，并立即返回该值.设置锁数量为1
	 */
	public boolean tryLock() {
		return sync.nonfairTryAcquire(1);
	}

	/**
	 * 尝试在指定时间内获取锁
	 * 指定时间内没获取到返回false
	 */
	public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException {
		return sync.tryAcquireNanos(1, unit.toNanos(timeout));
	}

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

	/**
	 * 构建一个Condition实例
	 */
	public Condition newCondition() {
		return sync.newCondition();
	}

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

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

	/**
	 * 查询是否被锁
	 */
	public boolean isLocked() {
		return sync.isLocked();
	}

	/**
	 *	是否是公平锁
	 */
	public final boolean isFair() {
		return sync instanceof FairSync;
	}

	/**
	 * 返回持有锁的线程
	 */
	protected Thread getOwner() {
		return sync.getOwner();
	}

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

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

参考文献:

【Java并发编程实战】—–“J.U.C”：ReentrantLock之二lock方法分析

源码来自JDK1.8,注释来自自己翻译,不足自出希望指正