重入锁ReentrantLock

重入锁

重入锁ReentrantLock，意思就是支持重进入的锁，它标识该锁能够支持一个线程对资源的重复加锁。

Synchronized关键字支持隐式的重进入。ReebtrantLock可以在调用lock()方法的线程（已经获取锁），可再次调用获取锁且不被阻塞。

重入锁获取锁有公平和非公平两种。

//这是ReentrantLock的2个构造函数
public ReentrantLock() {
        sync = new NonfairSync();
    }

public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

ReentrantLock的nonfairTryAcquire方法

//非公平
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; //增加同步状态值
                //对于tryRelease方法是减少同步状态值。
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

公平：如果一个锁是公平的，那么锁的获取顺序符合请求的顺序，一个队列。
非公平：只要CAS设置同步状态成功，则表示当前线程获取锁。

//这段代码是公平的获取锁
 protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
            //查看同步队列当前节点是否有前驱节点（也就是查看是否是head）
                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;
        }

非公平性锁虽然可能造成线程“饥饿”，但极少的线程切换，保证了其更大的吞吐量。