Reentrantlock

公平锁与非公平锁的源码
abstract static class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = -5179523762034025860L;
//抽象方法，当前lock只能由子类去实现。
abstract void lock();
//判断线程是否被独占，state是否为0，否的话，直接返回0.是的话，更新cas获取次数。state为0，cas设置state的值，将锁的所有者设置为当前线程，返回true。
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;
}
//将获取次数与释放次数，进行比较，不相同的话，直接抛出异常，相同的话，设置state新值为0。
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©;
return free;
}
//判断是否为锁的拥有者，是的话不需要检查
protected final boolean isHeldExclusively() {
return getExclusiveOwnerThread() == Thread.currentThread();
}

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

   //判断同步状态是否为0，如果是，则没有线程拥有锁，不是，则直接返回获取锁的线程。
    final Thread getOwner() {
        return getState() == 0 ? null : getExclusiveOwnerThread();
    }

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

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

    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        s.defaultReadObject();
        setState(0); // reset to unlocked state
    }
}

static final class FairSync extends Sync {
private static final long serialVersionUID = -3000897897090466540L;
//调用acquire让线程去同步排列获取。
final void lock() {
acquire(1);
}
//获取当前线程，得到同步状态，判断同步队列是否有前继节点，如果没有则表示获取成功，判断是否为当前线程，如果是则当前线程持有锁直接修改同步状态，如果不是当前线程持有锁则获取失败。
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;
}
}
2）ReentrantLock和Synchronized的比较
Synchronized是依赖于JVM实现的，而ReenTrantLock是JDK实现的，在Synchronized优化以前，synchronized的性能是比ReenTrantLock差很多的，但是自从Synchronized引入了偏向锁，轻量级锁（自旋锁）后，两者的性能就差不多了。
ReenTrantLock可以指定是公平锁还是非公平锁。而synchronized只能是非公平锁。所谓的公平锁就是先等待的线程先获得锁。
ReenTrantLock提供了一个Condition（条件）类，用来实现分组唤醒需要唤醒的线程们，而不是像synchronized要么随机唤醒一个线程要么唤醒全部线程。
ReenTrantLock提供了一种能够中断等待锁的线程的机制，通过lock.lockInterruptibly()来实现这个机制。