ReentrantLock源码

java.util.concurrent.locks.ReentrantLock implements Lock, java.io.Serializable

ReentrantLock称为可重入锁，其内部可以分成两种锁，公平锁和非公平锁，均通过继承自一个父类Sync实现，该父类有继承自AQS类

1.类变量&常量

    private final Sync sync;    //提供所有实现机制的同步器

2.构造方法

    //无参构造方法，默认构造一个非公平锁    public ReentrantLock() {        sync = new NonfairSync();    }    //有参构造方法，可以根据参数构造公平锁或非公平锁    public ReentrantLock(boolean fair) {        sync = fair ? new FairSync() : new NonfairSync();    }

3.重要方法

1.lock方法，调用sync的lock方法，实际使用时常用的加锁方式    public void lock() {        sync.lock();    }

2.  tryLock方法，若未获得锁不会一直等待，而是返回false      public boolean tryLock() {        return sync.nonfairTryAcquire(1);    }

3.  unlock方法，对锁的释放    public void unlock() {        sync.release(1);    }

4. isFair方法，判断是公平锁还是非公平锁    public final boolean isFair() {        return sync instanceof FairSync;    }

……………………可以看出ReentrantLock方法均调用sync的相关方法，故其实际是Sync锁的一个包装类

4.内部类

1.abstract static class Sync extends AbstractQueuedSynchronizerReentrantLock实现锁机制的最重要的内部类，继承自AQS类。tryAcquire、tryRelease和isHeldExclusively方法，继承AbstractQueueSynchronizer类1.1 tryAcquire方法在Sync类中为实现tryAcquire方法，因为是由Sync的子类来实现1.2 tryRelease方法，在释放时，不会考虑锁的顺序问题，故在Sync中实现//由于是可重入锁，故每释放一次锁，就将state减1。    protected final boolean tryRelease(int releases) {        int c = getState() - releases;        //若当前的线程与要释放锁的线程不一致，则抛出IllegalMonitorStateException(非法监视器状态异常)        if (Thread.currentThread() != getExclusiveOwnerThread())            throw new IllegalMonitorStateException();        boolean free = false;        //若是该线程最后一次持有锁，则通知AQS不再记录当前持有锁的线程        if (c == 0) {            free = true;            setExclusiveOwnerThread(null);        }        setState(c);        return free;    //释放成功返回true    }1.3 isHeldExclusively方法，判断当前持有锁的线程是否等于当前监听的线程    protected final boolean isHeldExclusively() {        return getExclusiveOwnerThread() == Thread.currentThread();    }1.4 getHoldCount方法，获取独占状态，如果当前线程是独占锁的线程，则返回当前标志位，否则返回0           final int getHoldCount() {        return isHeldExclusively() ? getState() : 0;    }1.5 getOwner方法，根据当前标识位返回线程，若为0则返回null，否则返回当前独占锁的线程    final Thread getOwner() {        return getState() == 0 ? null : getExclusiveOwnerThread();    }1.6 newCondition方法，应用于Condition条件时    final ConditionObject newCondition() {        return new ConditionObject();    }1.7 isLocked方法，表示当前是否被锁住    final boolean isLocked() {        return getState() != 0;    }1.8 readObject(ObjectInputStream)方法，用于序列化1.9 nonfairTryAcquire(int)方法，Sync的子类均会调用的一个方法，表示将当前线程加锁标志或可重入标识，是实现加锁功能的主要方法    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;    }

2.NonfairSync类，继承自Sync类，实现非公平锁    //tryAcquire方法，重写AQS中的tryAcquire方法，调用Sync中的nonfairTryAcquire方法，将当前线程加锁    protected final boolean tryAcquire(int acquires) {        return nonfairTryAcquire(acquires);    }    //lock方法，可以实现抢占式的占有锁。首先通过CAS操作，将标识位设为1。    //成功就将当前线程设置为独占锁的线程并返回，不成功再重新再sync队列中排队    final void lock() {        if (compareAndSetState(0, 1))            setExclusiveOwnerThread(Thread.currentThread());        else            acquire(1);    }

3.FairSync类，继承自Sync类，实现公平锁    //只在sync队列中排队    final void lock() {        acquire(1);    }    //tryAcquire方法，重写AQS中的tryAcquire方法，调用Sync中的nonfairTryAcquire方法，将当前线程加锁    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;    }