synchronized 原理剖析
synchronized 是 Java 提供的同步源语，它为 共享资源 提供了 原子性 和 可见性保障，本文通过原子性 和 可见性 二个维度剖析其实现原理
sync 原子性
通过 monitor 保障 原子性，具体表现为 monitorenter 和 monitorexit 或 ACC_SYNCHRONIZED 来实现加锁
加锁流程如下
锁降级流程
-
new 对象时，判断 是否开启偏差锁
- 开启偏差锁，构建匿名偏差锁（101）
- 敞开偏差锁，构建无锁对象（001）
- 无锁（001）遇到 线程加锁时，间接加自旋锁 / 轻量锁（00）
- 偏差锁 遇到 一个线程加锁时，锁状态不变，保留线程 ID
- 偏差锁 遇到 多个线程 交替加锁 时，线程跑到平安点，吊销偏差锁，降级为自旋锁 / 轻量锁（00）
- 自旋锁 是 每个线程通过 CAS 指令去更新对象头外面的 markword，如果自旋失败次数、或自旋等待时间过长，锁收缩成重量级锁（10）
- 重量级锁 由 ObjectMonitor 实现，须要由用户态切换到内核态
- 当竞争不强烈时，重量级锁 主动降级为轻量锁
monitorenter 源码剖析
CASE(_monitorenter): {
// 获取锁对象
oop lockee = STACK_OBJECT(-1);
// 在线程栈上找到一个闲暇的 BasicObjectLock 对象
BasicObjectLock* limit = istate->monitor_base();
BasicObjectLock* most_recent = (BasicObjectLock*) istate->stack_base();
BasicObjectLock* entry = NULL;
while (most_recent != limit) {if (most_recent->obj() == NULL) entry = most_recent;
else if (most_recent->obj() == lockee) break;
most_recent++;
}
if (entry != NULL) {
// 保留锁对象，表明以后 BasicObjectLock 持有锁对象 lockee
entry->set_obj(lockee);
int success = false;
uintptr_t epoch_mask_in_place = (uintptr_t)markOopDesc::epoch_mask_in_place;
markOop mark = lockee->mark(); // 获取锁对象的头部标记信息
// 获取没有 hash 值的标记位值，这里为 0
intptr_t hash = (intptr_t) markOopDesc::no_hash;
// 判断应用了偏差锁
if (mark->has_bias_pattern()) {
uintptr_t thread_ident;
uintptr_t anticipated_bias_locking_value;
thread_ident = (uintptr_t)istate->thread(); // 获取线程 id
anticipated_bias_locking_value =
(((uintptr_t)lockee->klass()->prototype_header() | thread_ident) ^ (uintptr_t)mark) &
～((uintptr_t) markOopDesc::age_mask_in_place);
/* anticipated_bias_locking_value 为 0，表明还没有批量撤销偏差锁，且以后线程
持有了偏差锁，间接退出 */
if (anticipated_bias_locking_value == 0) {
// already biased towards this thread, nothing to do
if (PrintBiasedLockingStatistics) {(* BiasedLocking::biased_lock_entry_count_addr())++;
}
success = true;
}
else if ((anticipated_bias_locking_value &
markOopDesc::biased_lock_mask_in_place) != 0) {
/* anticipated_bias_locking_value 不为 0，可能是批量撤销偏差锁，须要持续判断是否有
线程持有偏差锁，如果其余线程持有偏差锁，断定产生了抵触，就须要撤销偏差锁 */
markOop header = lockee->klass()->prototype_header();
if (hash != markOopDesc::no_hash) {header = header->copy_set_hash(hash);
}
// CAS 将对象头从 mark 替换为 header 撤销偏差锁
if (lockee->cas_set_mark(header, mark) == mark) {if (PrintBiasedLockingStatistics)
(*BiasedLocking::revoked_lock_entry_count_addr())++;
}
}
else if ((anticipated_bias_locking_value & epoch_mask_in_place) !=0) {
/* 如果 anticipated_bias_locking_value 不为 0，在批量撤销偏差锁时须要更改
epoch 的值，这里如果 epoch 扭转了，以后线程须要重偏差 */
markOop new_header = (markOop) ((intptr_t) lockee->klass()->prototype_header() | thread_ident);
if (hash != markOopDesc::no_hash) {new_header = new_header->copy_set_hash(hash);
}
// CAS 重偏差
if (lockee->cas_set_mark(new_header, mark) == mark) {if (PrintBiasedLockingStatistics)
(* BiasedLocking::rebiased_lock_entry_count_addr())++;
}
else {
// CAS 失败，产生了竞争，那么进入 monitorenter
CALL_VM(InterpreterRuntime::monitorenter(THREAD, entry), handle_exception);
}
success = true;
}
else {
/* 以上条件均不满足，表明开启了偏差锁，此时偏差锁状态为匿名偏差，尝试 CAS
将其偏差为以后线程 */
markOop header = (markOop) ((uintptr_t) mark &
((uintptr_t)markOopDesc::biased_lock_mask_in_place |
(uintptr_t)markOopDesc::age_mask_in_place |
epoch_mask_in_place));
if (hash != markOopDesc::no_hash) {header = header->copy_set_hash(hash);
}
markOop new_header = (markOop) ((uintptr_t) header | thread_ident);
// CAS 重偏差
if (lockee->cas_set_mark(new_header, header) == header) {if (PrintBiasedLockingStatistics)
(* BiasedLocking::anonymously_biased_lock_entry_count_addr())++;
}
else {
// CAS 失败，产生了竞争，那么进入 monitorenter
CALL_VM(InterpreterRuntime::monitorenter(THREAD, entry),
handle_exception);
}
success = true;
}
}
// 没有获取到锁，那么进入传统的轻量级锁
if (!success) {markOop displaced = lockee->mark()->set_unlocked();
entry->lock()->set_displaced_header(displaced);
bool call_vm = UseHeavyMonitors; // 判断是否间接应用重量级锁
/* 如果没有指定间接应用重量级锁，那么通过 CAS 操作尝试获取轻量级锁，即替换
头部指针，指向 entry */
if (call_vm || lockee->cas_set_mark((markOop)entry, displaced) != displaced) {
// 如果失败，可能是以后线程轻量级锁重入，那么判断是否是锁重入
if (!call_vm && THREAD->is_lock_owned((address) displaced->clear_lock_bits()))
{
// 轻量级锁重入，不须要设置 displaced_header 信息
entry->lock()->set_displaced_header(NULL);
} else {
// 否则调用 monitorenter
CALL_VM(InterpreterRuntime::monitorenter(THREAD, entry),
handle_exception);
}
}
}
UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);
} else {
// 如果未找到，设置 more_monitors 标记位，由解释器调配新的 BasicObjectLock 并重试
istate->set_msg(more_monitors);
UPDATE_PC_AND_RETURN(0); // Re-execute
}
}
sync 可见性
sync 通过 缓存一致性协定 保障可见性
MESI
M（modified）：批改
E（exclusive）：独占
S（shared）：共享
I（invalid）：有效
sync 和 Lock 的区别
应用
- sync 主动加锁、解锁，Lock 须要手动加锁、解锁
性能
- Lock 反对不同的 Condition（不同的期待队列），指定唤醒
-
Lock 能够应用 tryLock 反对超时
- sync 锁 不反对超时
-
Lock 能够应用 Lock.lockInterruptibly 响应中断
- 没有获取到 sync 锁 的线程处于 Blocked 状态不能响应 interrupt 中断
- Lock 反对偏心锁
原理
-
sync 底层由 4 种不同状态的锁降级实现，Lock 由 CAS 实现，属于乐观锁
- 无锁、偏差锁、轻量锁都属于用户态
- 轻量锁 由 CAS 实现，属于乐观锁
- 重量级锁由 Monitor 实现，属于乐观锁