synchronized 原理分析

synchronized 原理分析

synchronized 是Java 提供的同步源语,它为 共享资源 提供了原子性 和 可见性保障,本文通过原子性 和 可见性 二个维度分析其实现原理

sync 原子性

通过 monitor 保证 原子性,具体表现为 monitorenter 和 monitorexit 或 ACC_SYNCHRONIZED 来实现加锁

加锁流程如下
synchronized 原理分析_第1张图片

锁升级流程
  • 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):无效

synchronized 原理分析_第2张图片

sync 和 Lock 的区别

使用

  • sync 自动加锁、解锁,Lock 需要手动加锁、解锁

功能

  • Lock 支持不同的Condition(不同的等待队列),指定唤醒
  • Lock 可以使用 tryLock 支持超时

    • sync锁 不支持超时
  • Lock 可以使用Lock.lockInterruptibly 响应中断

    • 没有获取到 sync锁 的线程处于 Blocked 状态不能响应interrupt中断
  • Lock 支持公平锁

原理

  • sync 底层由4种不同状态的锁升级实现, Lock 由 CAS 实现,属于乐观锁

    • 无锁、偏向锁、轻量锁都属于用户态
    • 轻量锁 由CAS实现,属于乐观锁
    • 重量级锁由 Monitor 实现,属于悲观锁

你可能感兴趣的