ObjectMonitor() {_header       = NULL;_count        = 0; //记录线程获取锁的次数_waiters      = 0;_recursions   = 0; //锁的重入次数_object       = NULL;_owner        = NULL;//指向持有ObjectMonitor对象的线程_WaitSet      = NULL; //等待条件队列 类似AQS的ConditionObject_WaitSetLock  = 0 ;_Responsible  = NULL ;_succ         = NULL ;_cxq          = NULL ;FreeNext      = NULL ;_EntryList    = NULL ; //同步队列 类似AQS的CLH队列_SpinFreq     = 0 ;_SpinClock    = 0 ;OwnerIsThread = 0 ;_previous_owner_tid = 0;}

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) // overflowthrow 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;//只有线程全部释放才返回truesetExclusiveOwnerThread(null); //同步队列的线程都可以去获取同步状态了
            }setState(c); return free;}

public void lock() {sync.lock();//获取锁
}
public void unlock() {sync.release(1); //释放锁
}

public final boolean release(int arg) {if (tryRelease(arg)) {//调用子类的tryRelease 实际就是Sync的tryReleaseNode h = head;//取同步队列的头节点if (h != null && h.waitStatus != 0)//同步队列头节点不为空且不是初始状态unparkSuccessor(h);//释放头节点 唤醒后续节点return true;}return false;
}

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

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() {if (compareAndSetState(0, 1))//通过CAS来获取同步状态 也就是锁setExclusiveOwnerThread(Thread.currentThread());//获取成功线程占有锁elseacquire(1);//获取失败 进入AQS同步队列排队等待 执行AQS的acquire方法
        }protected final boolean tryAcquire(int acquires) {return nonfairTryAcquire(acquires);}}

static final class FairSync extends Sync {private static final long serialVersionUID = -3000897897090466540L;final void lock() {acquire(1);//严格按照AQS的同步队列要求去获取同步状态
        }/*** Fair version of tryAcquire.  Don't grant access unless* recursive call or no waiters or is first.*/protected final boolean tryAcquire(int acquires) {final Thread current = Thread.currentThread();//获取当前线程int c = getState();if (c == 0) {//锁未被抢占if (!hasQueuedPredecessors() &&//没有前驱节点compareAndSetState(0, acquires)) {//CAS获取同步状态
                    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;}}

public final boolean hasQueuedPredecessors() {// The correctness of this depends on head being initialized// before tail and on head.next being accurate if the current// thread is first in queue.Node t = tail; // Read fields in reverse initialization order 尾节点Node h = head;//头节点
        Node s;return h != t &&//头尾节点不是一个 即队列存在排队线程((s = h.next) == null || s.thread != Thread.currentThread());//头节点的后续节点为空或者不是当前线程}

ReentrantLock lock = new ReentrantLock();
try {lock.lock();//……}finally {lock.unlock();}

public boolean tryLock()// 尝试获取锁,立即返回获取结果 轮询锁
public boolean tryLock(long timeout, TimeUnit unit)//尝试获取锁,最多等待 timeout 时长 超时锁
public void lockInterruptibly()//可中断锁,调用线程 interrupt 方法,则锁方法抛出 InterruptedException  中断锁