你是否深入解析过java虚拟机：并发设施，锁优化？

void InterpreterMacroAssembler::lock_object(Register lock_reg) {
// 如果强制使用重量级锁，lock_object()就不做优化了
if (UseHeavyMonitors) { ... } else {
...
// 将加锁对象放入obj_reg寄存器
movptr(obj_reg, Address(lock_reg, obj_offset));
// 如果开启偏向锁优化且偏向加锁成功，跳转到done，
// 否则跳到slow_case使用重量级锁
if (UseBiasedLocking) { biased_locking_enter(...); }
// 加载1到swap_reg
movl(swap_reg, (int32_t)1);
// 获取加锁对象的对象头，与1做位或运算，结果放入swap_reg
orptr(swap_reg,
Address(obj_reg, oopDesc::mark_offset_in_bytes()));
// 再将swap_reg保存到Displaced Headermovptr(Address(lock_reg, mark_offset), swap_reg);
// 使用对象头和swap_reg做比较，如果相等，将对象头替换为指向栈顶基本对象锁的指针，
// 加锁完成跳到done。否则将swap_reg设置为基本对象指针
lock();
cmpxchgptr(lock_reg,
Address(obj_reg, oopDesc::mark_offset_in_bytes()));
jcc(Assembler::zero, done);
// 加锁失败，再看看当前对象头是否已经是指向栈顶基本对象锁
const int zero_bits = LP64_ONLY(7) NOT_LP64(3);
subptr(swap_reg, rsp);
andptr(swap_reg, zero_bits - os::vm_page_size());
movptr(Address(lock_reg, mark_offset), swap_reg);
// 如果成功表示已经加过锁，跳到done完成。否则lock_object各种优化均失败，进入slow_
// case执行重量级锁
jcc(Assembler::zero, done);
// 重量级锁
bind(slow_case);
call_VM(...InterpreterRuntime::monitorenter);
bind(done);
}
}

void ObjectMonitor::enter(TRAPS) {
// CAS抢锁，如果当前线程抢到锁则直接返回
Thread * const Self = THREAD;
void * cur = Atomic::cmpxchg(Self, &_owner, (void*)NULL);
if (cur == NULL) {
return;
}
// 否则CAS返回_owner给cur，_owner的值可能是线程指针，也可能是基本对象锁
// 检查_owner是否为当前线程指针，如果是则当前线程再次加锁（递归计数加一）
if (cur == Self) {_recursions++;
return;
}
// 检查_owner是否为位于当前线程栈上的基本对象锁，如果是则递归计数加一以加锁
if (Self->is_lock_owned ((address)cur)) {
_recursions = 1;
_owner = Self;
return;
}
// 否则当前对象锁的_owner是其他线程或者位于其他线程栈上的基本对象锁
// 尝试自旋来和其他线程竞争该锁
Self->_Stalled = intptr_t(this);
if (TrySpin(Self) > 0) {
Self->_Stalled = 0;
return;
}
// 如果自旋竞争失败
JavaThread * jt = (JavaThread *) Self;
Atomic::inc(&_count);
{
// 改变当前线程状态，使其阻塞在对象锁上
...
EnterI(THREAD);
...
// 阻塞结束，线程继续执行exit(false, Self);
...
}
Atomic::dec(&_count);
Self->_Stalled = 0;
}
void ObjectMonitor::exit(bool not_suspended, TRAPS) {
Thread * const Self = THREAD;
// 如果_owner不是当前线程
if (THREAD != _owner) {
...
}
// 否则_owner是当前线程，或者当前线程栈上的基本对象锁
// 如果已经加过锁，递归计数减一即可
if (_recursions != 0) {
_recursions--;
return;
}
_Responsible = NULL;
// 由于当前线程没有递归加锁，同时又是对象锁的持有者，这意味着当前线程执行对象锁的exit，
// 同时还需要找到下一个待唤醒的线程，因为如果当前线程结束了同步执行又没有唤醒其他线程，
// 那么其他线程会无限等待下去
for (;;) {
// 将对象锁持有者置空
OrderAccess::release_store(&_owner, (void*)NULL);
OrderAccess::storeload();// 如果没有其他线程竞争对象锁，直接返回
if ((intptr_t(_EntryList)|intptr_t(_cxq)) == 0 || _succ != NULL){
return;
}
if (!Atomic::replace_if_null(THREAD, &_owner)) {
return;
}
// 如果EntryList中存在等待对象锁的线程
ObjectWaiter * w = NULL;
w = _EntryList;
if (w != NULL) {
ExitEpilog(Self, w);
return;
}
// cxq中存在等待对象锁的线程，将线程从cxq转移到EntryList
// ---- 1. 保存cxq
w = _cxq;
if (w == NULL) continue;
// ---- 2. 将cxq置空
for (;;) {
ObjectWaiter * u = Atomic::cmpxchg(NULL, &_cxq, w);
if (u == w) break;
w = u;
}
// ---- 3.将cxq转移到EntryList
_EntryList = w;// 将EntryList中的所有线程设置为TS_ENTER
ObjectWaiter * q = NULL;
ObjectWaiter * p;
for (p = w; p != NULL; p = p->_next) {
p->TState = ObjectWaiter::TS_ENTER;
p->_prev = q;
q = p;
}
if (_succ != NULL) continue;
// 唤醒EntryList的第一个线程
w = _EntryList;
if (w != NULL) {
ExitEpilog(Self, w);
return;
}
}
}