ReentrantLock：API层面的互斥（lock()和unlock()方法配合try/finally完成）
synchronized：原生语法层面的互斥锁。
ReentrantLock相较于synchronized的高级功能
等待可中断：当持有锁的线程长期不释放锁的时候，正在等待的线程可以放弃等待
可实现公平锁：多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获取锁。非公平锁不保证这一点，在锁被释放时，任何一个等待锁的线程都有集会获得锁。synchronized是非公平锁，ReentrantLock默认非公平锁，可通过构造参数使用公平锁
锁绑定多个条件：一个ReentrantLock对象可以同时绑定多个Condition对象，而在synchronized中，锁对象的wait()和notify()和notifyAll()方法可以实现一个隐含的条件，如果要和对于一个的条件关联的时候，就不得不额外添加一个所，而ReentrantLock只需要调用newCondition()方法即可
1.ReentrantLock内部结构
/**
* 内部调用AQS，基于该成员属性
*/
private final Sync sync;
abstract static class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = -5179523762034025860L;
/**
* 抽象加锁方法，由子类 公平锁NonfairSync 、非公平锁NonfairSync 分别实现
*/
abstract void lock();
/**
* 尝试获取非公平锁
*/
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
//非公平锁不需要判断同步队列（CLH）中是否有等待线程
// 判断state状态是否为0，不为0可以加锁
if (c == 0) {
//unsafe操作，cas修改state状态
if (compareAndSetState(0, acquires)) {
//独占状态锁持有者指向当前线程
setExclusiveOwnerThread(current);
return true;
}
}
// 可重入锁实现方式
//state状态不为0，判断锁持有者是否是当前线程，
//如果是当前线程持有 则state+1
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;
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() {
return getState() == 0 ? null : getExclusiveOwnerThread();
}
final int getHoldCount() {
return isHeldExclusively() ? getState() : 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
}
}
/**
* Sync object for fair locks 公平锁
*/
static final class FairSync extends Sync {
private static final long serialVersionUID = -3000897897090466540L;
final void lock() {
//调用AQS中定义的方法，AQS第一步会调用下边的tryAcquire，详见AQS.acquire
acquire(1);
}
/**
* 重写AQS中的tryAcquire方法逻辑
* 尝试加锁，被AQS的acquire()方法调用
*/
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
// 先判断队列当中是否有等待的节点
// 如果没有则可以尝试CAS获取锁
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;
}
}
/**
* Sync object for non-fair locks 非公平锁
*/
static final class NonfairSync extends Sync {
private static final long serialVersionUID = 7316153563782823691L;
/**
* Performs lock. Try immediate barge, backing up to normal
* acquire on failure.
*/
final void lock() {
//直接尝试加锁，不会去判断同步队列(CLH队列)中是否有排队等待加锁的节点
if (compareAndSetState(0, 1))
//独占线程指向当前线程
setExclusiveOwnerThread(Thread.currentThread());
else
// 如果当前有人占用锁，再尝试去加一次锁，详见AQS.acquire
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
// 非公平锁获取定义在父类Sync中
return nonfairTryAcquire(acquires);
}
}
2.构造器
/**
* 默认创建非公平锁对象，非公平锁详见上方内部结构
*/
public ReentrantLock() {
sync = new NonfairSync();
}
/**
* 根据入参创建公平锁或非公平锁，公平锁详见上方内部结构
*/
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
3.lock()、tryLock()方法
NonfairSync.tryAcquire = Sync.nonfairTryAcquire
lock->FairSync.lock->AQS.acquire->FairSync.tryAcquire
lock->NonfairSync.lock->AQS.acquire->NonfairSync.tryAcquire
//trylock 使用非公平锁加锁
tryLock->Sync.nonfairTryAcquire
tryLock(time)->AQS.tryAcquireNanos->FairSync.tryAcquire || AQS.doAcquireNanos(时间内循环->FairSync.tryAcquire)
tryLock(time)->AQS.tryAcquireNanos->NonfairSync.tryAcquire || AQS.doAcquireNanos(时间内循环->NonfairSync.tryAcquire)
/**
* 如果锁没有被持有，直接加锁
* 如果锁被当前线程持有，state+1
* 如果锁被其他线程持有，等待直至加锁成功
*/
public void lock() {
// 公平锁、非公平锁各自实现的lock方法
sync.lock();
}
/**
* 尝试加锁，成功直接返回true，否则直接false
*/
public boolean tryLock() {
// 详见上边sync内部结构nonfairTryAcquire方法
return sync.nonfairTryAcquire(1);
}
/**
* 指定等待时间内尝试加锁
*/
public boolean tryLock(long timeout, TimeUnit unit)
throws InterruptedException {
// 详见AQS文章
return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}
3.unlock()
AQS.release->(sync.tryRelease->AQS.unparkSuccessor)
/**
* 解锁，释放一个锁，唤醒一个阻塞线程
*/
public void unlock() {
//AQS.release->(sync.tryRelease->AQS.unparkSuccessor)
sync.release(1);
}
结合AQS一起看
