HotSpot synchronized原理

最新推荐文章于 2022-08-31 21:49:41 发布
最新推荐文章于 2022-08-31 21:49:41 发布
阅读量563 收藏
点赞数
分类专栏： HotSpot 文章标签： hotspot jvm synchronize
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013928208/article/details/108884099
版权

Java通过对synchronized关键字来支持多线程同步。在字节码层面synchronized表现为monitorenter, monitorexit， 同时外加一个flags标志区分synchronized的同步作用域。synchronized用的锁是存在Java对象头里的，虚拟机的对象头主要包括两部分数据：Mark Word(标记字段)和Klass Pointer(类元数据指针)，其中Klass Point是是对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例，Mark Word用于存储对象自身的运行时数据，它是实现轻量级锁和偏向锁的关键。Mark Word用于存储对象自身的运行时数据，如哈希码（HashCode）、GC分代年龄、锁状态标志、线程持有的锁、偏向线程 ID、偏向时间戳等等。

在这里插入图片描述

一.同步

在生成方法entry_point时会在方法栈帧分配锁对象空间，用于存放锁。在模板表中也对应有monitorenter()模板指令的支持。Java语言层面任意对象，或类都可已当成锁。如：Object.class, this, 对象实例。HotSpot在底层通过偏向锁，轻量级锁，重量级锁三种锁支持Java语言层面的同步。

1.方法同步

对于整个方法同步，entry_point直接提供了lock_method，并在方法栈帧上分配了一个锁位

hotspot/src/cpu/x86/vm/templateInterpreterGenerator_x86.cpp

address TemplateInterpreterGenerator::generate_normal_entry(bool synchronized) {
 if (synchronized) {
    // Allocate monitor and lock method
    lock_method();
  }
}

hotspot/src/cpu/x86/vm/templateInterpreterGenerator_x86.cpp

void TemplateInterpreterGenerator::lock_method() {
  //计算
  const Address access_flags(rbx, Method::access_flags_offset());
  const Address monitor_block_top(
        rbp,
        frame::interpreter_frame_monitor_block_top_offset * wordSize);
  const int entry_size = frame::interpreter_frame_monitor_size() * wordSize;
  // 获取锁对象
    Label done;
    __ movl(rax, access_flags);
    __ testl(rax, JVM_ACC_STATIC);
    // 局部变量表中第一个变量，存放着即将锁的对象指针，移动到rax中
    __ movptr(rax, Address(rlocals, Interpreter::local_offset_in_bytes(0)));
    __ jcc(Assembler::zero, done);
    __ load_mirror(rax, rbx);

  //分配和加锁
  __ subptr(rsp, entry_size); //分配
  __ movptr(monitor_block_top, rsp);  //移动
  // 存储对象指针到BasicObjectLock
  __ movptr(Address(rsp, BasicObjectLock::obj_offset_in_bytes()), rax);
  const Register lockreg = NOT_LP64(rdx) LP64_ONLY(c_rarg1);
  __ movptr(lockreg, rsp);
  //锁定
  __ lock_object(lockreg);
}

2.代码块同步

hotspot/src/cpu/x86/vm/templateTable_x86.cpp
一段代码块可能有多个synchronize修饰，会在栈帧中存在多个monitor entry

void TemplateTable::monitorenter() {
  //计算[monitor entry]对应的内存段
  const Address monitor_block_top(
        rbp, frame::interpreter_frame_monitor_block_top_offset * wordSize);
  const Address monitor_block_bot(
        rbp, frame::interpreter_frame_initial_sp_offset * wordSize);
  const int entry_size = frame::interpreter_frame_monitor_size() * wordSize;

  Label allocated;
  
  //当前entry信息
  Register rtop = LP64_ONLY(c_rarg3) NOT_LP64(rcx);
  Register rbot = LP64_ONLY(c_rarg2) NOT_LP64(rbx);
  Register rmon = LP64_ONLY(c_rarg1) NOT_LP64(rdx);

  // initialize entry pointer
  __ xorl(rmon, rmon); // points to free slot or NULL

  // 找到一个空闲entry位置
  {
    ......
  }

  __ testptr(rmon, rmon); // check if a slot has been found
  __ jcc(Assembler::notZero, allocated); // if found, continue with that one

  // 没有找到空闲位置，则新分配一个
  {
    ......
  }

  // call run-time routine
  // rmon: 指向entry
  __ bind(allocated);
  __ increment(rbcp);

  // 存储对象指针到BasicObjectLock
  __ movptr(Address(rmon, BasicObjectLock::obj_offset_in_bytes()), rax);
  __ lock_object(rmon);
  ......
  __ dispatch_next(vtos);
}

二.加锁

hotspot/src/cpu/x86/vm/interp_masm_x86.cpp
如果设置了UseHeavyMonitors，则不会使用其他锁，偏置锁分配失败走slow_case，进行锁升级

void InterpreterMacroAssembler::lock_object(Register lock_reg) {
  //使用重量级锁，转到InterpreterRuntime::monitorenter执行
  if (UseHeavyMonitors) {
    call_VM(noreg,
            CAST_FROM_FN_PTR(address, InterpreterRuntime::monitorenter),
            lock_reg);
  } else {
    Label done;
    Label slow_case;

    //取对象指针
    movptr(obj_reg, Address(lock_reg, obj_offset));
    //如果使用偏执锁，走biased_locking_enter，否则走slow_case
    if (UseBiasedLocking) {
      biased_locking_enter(lock_reg, obj_reg, swap_reg, tmp_reg, false, done, &slow_case);
    }
    //......
    bind(slow_case);

    // Call the runtime routine for slow case
    call_VM(noreg,
            CAST_FROM_FN_PTR(address, InterpreterRuntime::monitorenter),
            lock_reg);

    bind(done);
  }
}

1.偏向加锁

hotspot/src/cpu/x86/vm/macroAssembler_x86.cpp
偏向锁的锁对象保存了当前偏向的线程ID，如果是同一线程重复加锁，则只需检查线程ID,减少加锁去锁开销。如果当前线程已加锁，且锁是偏向锁，有其他线程竞争则偏向锁将被撤销。如果偏向锁过期或失效，则线程竞争偏向锁将重偏。对于轻量级锁在出现竞争时，将自旋等待。

int MacroAssembler::biased_locking_enter(Register lock_reg,
                                         Register obj_reg,
                                         Register swap_reg,
                                         Register tmp_reg,
                                         bool swap_reg_contains_mark,
                                         Label& done,
                                         Label* slow_case,
                                         BiasedLockingCounters* counters) {
   
  Address mark_addr      (obj_reg, oopDesc::mark_offset_in_bytes());
  // Biased locking
  
  Label cas_label;
  ......
  jcc(Assembler::equal, done);

  Label try_revoke_bias;
  Label try_rebias;

  //检查是否需要撤销偏向
  testptr(header_reg, markOopDesc::biased_lock_mask_in_place);
  jccb(Assembler::notZero, try_revoke_bias);

  //检查是否需要重偏向
  testptr(header_reg, markOopDesc::epoch_mask_in_place);
  jccb(Assembler::notZero, try_rebias);

 //CAS获取并设置偏向锁
  NOT_LP64( movptr(swap_reg, saved_mark_addr); )
  andptr(swap_reg,
         markOopDesc::biased_lock_mask_in_place | markOopDesc::age_mask_in_place | markOopDesc::epoch_mask_in_place);
#ifdef _LP64
  movptr(tmp_reg, swap_reg);
  orptr(tmp_reg, r15_thread);
#else
  get_thread(tmp_reg);
  orptr(tmp_reg, swap_reg);
#endif
  if (os::is_MP()) {
    lock();
  }
  //如果有其他线程竞争，走slow_case
  cmpxchgptr(tmp_reg, mark_addr);
  if (counters != NULL) {
    cond_inc32(Assembler::zero,
               ExternalAddress((address) counters->anonymously_biased_lock_entry_count_addr()));
  }
  if (slow_case != NULL) {
    jcc(Assembler::notZero, *slow_case);
  }
  jmp(done);

  bind(try_rebias);
  //偏向过期，可重偏
  load_prototype_header(tmp_reg, obj_reg);
#ifdef _LP64
  orptr(tmp_reg, r15_thread);
#else
  get_thread(swap_reg);
  orptr(tmp_reg, swap_reg);
  movptr(swap_reg, saved_mark_addr);
#endif
  if (os::is_MP()) {
    lock();
  }
   //如果有其他线程竞争，走slow_case
  cmpxchgptr(tmp_reg, mark_addr); 
  if (counters != NULL) {
    cond_inc32(Assembler::zero,
               ExternalAddress((address) counters->rebiased_lock_entry_count_addr()));
  }
  if (slow_case != NULL) {
    jcc(Assembler::notZero, *slow_case);
  }
  jmp(done);

  bind(try_revoke_bias);
  //撤销偏向
  NOT_LP64( movptr(swap_reg, saved_mark_addr); )
  load_prototype_header(tmp_reg, obj_reg);
  if (os::is_MP()) {
    lock();
  }
  cmpxchgptr(tmp_reg, mark_addr); 
  if (counters != NULL) {
    cond_inc32(Assembler::zero,
               ExternalAddress((address) counters->revoked_lock_entry_count_addr()));
  }

  bind(cas_label);

  return null_check_offset;
}

2.撤销与重偏向

hotspot/src/share/vm/interpreter/interpreterRuntime.cpp

IRT_ENTRY_NO_ASYNC(void, InterpreterRuntime::monitorenter(JavaThread* thread, BasicObjectLock* elem))
  if (UseBiasedLocking) {
    // Retry fast entry if bias is revoked to avoid unnecessary inflation
    ObjectSynchronizer::fast_enter(h_obj, elem->lock(), true, CHECK);
  } else {
    ObjectSynchronizer::slow_enter(h_obj, elem->lock(), CHECK);
  }
IRT_END

hotspot/src/share/vm/runtime/synchronizer.cpp

void ObjectSynchronizer::fast_enter(Handle obj, BasicLock* lock,
                                    bool attempt_rebias, TRAPS) {
  if (UseBiasedLocking) { //使用偏向锁
    if (!SafepointSynchronize::is_at_safepoint()) {//不在安全点
      //撤销或重偏
      BiasedLocking::Condition cond = BiasedLocking::revoke_and_rebias(obj, attempt_rebias, THREAD);
      if (cond == BiasedLocking::BIAS_REVOKED_AND_REBIASED) {
        return;
      }
    } else {
      BiasedLocking::revoke_at_safepoint(obj);
    }
  }
  //慢速
  slow_enter(obj, lock, THREAD);
}

hotspot/src/share/vm/runtime/biasedLocking.cpp

  1. is_biased_anonymously为true，表明对象锁未偏向任一线程，执行撤销偏向锁
  2. has_bias_pattern为true,表明对象锁。处于可偏向状态
  3. has_bias_pattern为true，kclass对象锁与obj对象锁不一致，执行撤销
  4. has_bias_pattern为true，epoch过期，执行撤销
  5. has_bias_pattern为true，epoch过期，允许重偏向，执行撤销并重偏向
BiasedLocking::Condition BiasedLocking::revoke_and_rebias(Handle obj, bool attempt_rebias, TRAPS) {
  markOop mark = obj->mark();
  if (mark->is_biased_anonymously() && !attempt_rebias) {
   //对象处于可偏向状态， 且 线程ID  为空， 表示尚未偏向于任意一个线程
    markOop biased_value       = mark;
    markOop unbiased_prototype = markOopDesc::prototype()->set_age(mark->age());
    markOop res_mark = (markOop) Atomic::cmpxchg_ptr(unbiased_prototype, obj->mark_addr(), mark);
    if (res_mark == biased_value) {
      return BIAS_REVOKED;
    }
  } else if (mark->has_bias_pattern()) { //可偏向
    Klass* k = obj->klass();
    markOop prototype_header = k->prototype_header();
    if (!prototype_header->has_bias_pattern()) {//不可偏，撤销偏向
      markOop biased_value       = mark;
      markOop res_mark = (markOop) Atomic::cmpxchg_ptr(prototype_header, obj->mark_addr(), mark); 
      return BIAS_REVOKED;
    } else if (prototype_header->bias_epoch() != mark->bias_epoch()) { //偏向过期
    
      if (attempt_rebias) { //进行撤销重偏
        markOop biased_value       = mark;
        markOop rebiased_prototype = markOopDesc::encode((JavaThread*) THREAD, mark->age(), prototype_header->bias_epoch());
        markOop res_mark = (markOop) Atomic::cmpxchg_ptr(rebiased_prototype, obj->mark_addr(), mark);
        if (res_mark == biased_value) {
          return BIAS_REVOKED_AND_REBIASED;
        }
      } else {//仅撤销
        markOop biased_value       = mark;
        markOop unbiased_prototype = markOopDesc::prototype()->set_age(mark->age());
        markOop res_mark = (markOop) Atomic::cmpxchg_ptr(unbiased_prototype, obj->mark_addr(), mark);
        if (res_mark == biased_value) {
          return BIAS_REVOKED;
        }
      }
    }
  }
  //......
  return bulk_revoke.status_code();
}

3.锁膨胀

hotspot/src/share/vm/runtime/synchronizer.cpp

void ObjectSynchronizer::slow_enter(Handle obj, BasicLock* lock, TRAPS) {
  markOop mark = obj->mark();
  if (mark->is_neutral()) {//未持有锁，保存原来的对象头
    lock->set_displaced_header(mark);
    if (mark == (markOop) Atomic::cmpxchg_ptr(lock, obj()->mark_addr(), mark)) {
      TEVENT(slow_enter: release stacklock);
      return;
    }
    // Fall through to inflate() ...
  } else if (mark->has_locker() &&
             THREAD->is_lock_owned((address)mark->locker())) {//加锁状态且是当前线程的锁
    lock->set_displaced_header(NULL);
    return;
  }
  //否则，进行锁膨胀
  lock->set_displaced_header(markOopDesc::unused_mark());
  ObjectSynchronizer::inflate(THREAD,
                              obj(),
                              inflate_cause_monitor_enter)->enter(THREAD);
}

hotspot/src/share/vm/runtime/synchronizer.cpp

  1. 对象锁是重量级锁，无法膨胀了，返回
  2. 对象锁正在膨胀，自旋
  3. 对象锁是轻量级锁，则分配一个重量级锁，设置给锁对象
  4. 未持有锁，分配一个重量级锁，设置给锁对象
ObjectMonitor* ObjectSynchronizer::inflate(Thread * Self,
                                                     oop object,
                                                     const InflateCause cause) {
  for (;;) {
    const markOop mark = object->mark();
    // The mark can be in one of the following states:
    // *  Inflated     - just return
    // *  Stack-locked - coerce it to inflated
    // *  INFLATING    - busy wait for conversion to complete
    // *  Neutral      - aggressively inflate the object.
    // *  BIASED       - Illegal.  We should never see this

    // CASE: inflated
    if (mark->has_monitor()) { //当前是重量级锁，直接返回
      ObjectMonitor * inf = mark->monitor();
      event.cancel(); // let's not post an inflation event, unless we did the deed ourselves
      return inf;
    }

    //锁正在膨胀，循环等待
    if (mark == markOopDesc::INFLATING()) {
      continue;
    }

   
    if (mark->has_locker()) { //当前是轻量级锁，则分配一个重量级锁，设置给锁对象
      ObjectMonitor * m = omAlloc(Self);
      m->Recycle();
      m->_Responsible  = NULL;
      m->_recursions   = 0;
      m->_SpinDuration = ObjectMonitor::Knob_SpinLimit;   // Consider: maintain by type/class

      markOop cmp = (markOop) Atomic::cmpxchg_ptr(markOopDesc::INFLATING(), object->mark_addr(), mark);
      if (cmp != mark) {
        omRelease(Self, m, true);
        continue;       // Interference -- just retry
      }
      markOop dmw = mark->displaced_mark_helper();
      // Setup monitor fields to proper values -- prepare the monitor
      m->set_header(dmw);
      m->set_owner(mark->locker());
      m->set_object(object);
      object->release_set_mark(markOopDesc::encode(m));
      OM_PERFDATA_OP(Inflations, inc());
      TEVENT(Inflate: overwrite stacklock);
      if (event.should_commit()) {
        post_monitor_inflate_event(event, object, cause);
      }
      return m;
    }

    //如果走到这里，则未持有锁，分配一个重量级锁，设置给锁对象
    ObjectMonitor * m = omAlloc(Self);
    // prepare m for installation - set monitor to initial state
    m->Recycle();
    m->set_header(mark);
    m->set_owner(NULL);
    m->set_object(object);
    m->_recursions   = 0;
    m->_Responsible  = NULL;
    m->_SpinDuration = ObjectMonitor::Knob_SpinLimit;       // consider: keep metastats by type/class

    if (Atomic::cmpxchg_ptr (markOopDesc::encode(m), object->mark_addr(), mark) != mark) {
      m->set_object(NULL);
      m->set_owner(NULL);
      m->Recycle();
      omRelease(Self, m, true);
      m = NULL;
      continue;
    }
    
    return m;
  }
}

如果一个线程获取到了偏向锁，在没有其他线程竞争的情况下，如果下次再执行该同步块时则只需要简单判断当前偏向锁所偏向的对象是否是当前线程，如果是则不需要再进行任何获取锁与释放锁的过程，直接执行同步块。当一个线程获取到该锁后，另一个线程也来获取该锁，这个线程并不会被直接阻塞，而是通过自旋来等待该锁被释放，所谓的自旋就是让线程执行一段无意义的循环。如果多个线程同时竞争锁，只会有一个线程得到这把锁，其他线程获取锁失败不会和轻量级锁进行自旋等待锁被释放，而是直接阻塞没有获取成功的线程。

SherlockCharlie
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java-并发-锁-synchronized
迷路剑客个人博客
12-21 483
Java-并发-锁-synchronized 摘要 本文会详细说下synchronized的底层实现原理。 0x01 基本概念 每次只能有一个线程进入临界区 保证临界区内共享变量的可见性和有序性 成功进入synchronized区域的线程可以拿到对象的Object-Monitor。具体有3种用法，作用域不同，在后面例子中介绍。 对于拿到锁的线程来说，同一个对象的synchronized具有可重入...
JAVA锁分析之synchronized
zxz1580977728的博客
11-10 257
123
Java 多线程学习（6）synchronized 的成神之路
HappyFeet的博客
02-11 458
我的 synchronized 的成神之路。
Hotspot synchronized与volatile关键字实现（二） 源码解析
菜鸟进阶之路
03-20 1215
目录 一、synchronized底层实现 1、修饰代码块字节码分析 2、InterpreterGenerator::lock_method 3、执行本地方法synchronized解锁 4、解释执行普通Java方法synchronized解锁 二、jni_MonitorEnter /jni_MonitorExit 1、jni_MonitorEnter 2、jni_Moni...
死磕Synchronized底层实现--偏向锁
weixin_33816300的博客
11-28 547
本文为synchronized系列第二篇。主要内容为分析偏向锁的实现。 偏向锁的诞生背景和基本原理在上文中已经讲过了，强烈建议在有看过上篇文章的基础下阅读本文。 更多文章见个人博客：github.com/farmerjohng… 本系列文章将对HotSpot的synchronized锁实现进行全面分析，内容包括偏向锁、轻量级锁、重量级锁的加锁、解锁、锁升级流程的原理及源码分析，希望给在研究sync...
Java中synchronized实现原理详解
08-28
Java中的`synchronized`关键字是实现线程同步的关键，它的实现原理涉及到多个方面，包括Java对象头、Monitor（监视器锁）以及一系列的锁优化策略。本文将深入探讨这些概念。 首先，`synchronized`用于保证多线程...
synchronized锁原理分析（一、从Java对象头看synchronized锁的状态）
12-21
《深入剖析synchronized锁原理——从Java对象头的角度》 synchronized关键字在Java中扮演着重要的角色，它是Java实现同步的基础，确保了多线程环境下的数据一致性。不同于基于JDK实现的Lock接口（如ReentrantLock）...
hotspot 源码（JDK8）
11-10
JDK8u-hotspot源码提供了对Hotspot内部工作原理的深入了解，这对于Java开发者优化性能、调试问题以及理解JVM内部机制至关重要。Hotspot的主要目标是通过即时编译（JIT）和各种优化技术，为Java应用程序提供卓越的...
JDK10（JDK10底层C++源码及hotspot虚拟机源码）
最新发布
12-14
5. **线程与同步（Threads and Synchronization）**：HotSpot实现了Java的线程模型和同步原语，如`synchronized`关键字和`volatile`变量。 通过研究JDK10的源码，开发者可以了解到Java运行时的内部工作原理，包括...
synchronized和LOCK的实现原理深入JVM锁机制比较好.docx
07-09
了解 JVM 锁机制中的 synchronized 和 Lock 实现原理 在 Java 中，锁机制是数据同步的关键，存在两种锁机制：synchronized 和 Lock。了解这两种锁机制的实现原理对于理解 Java 并发编程非常重要。 synchronized 锁...
Java Synchronized实现互斥之应用与源码初探
09-12 535
前言 上篇文章从无到有分析了如何实现"锁"，虽然仅仅实现了最简单的锁，但"锁"的精华已经提取出来了，有了这些知识，本篇将分析系统提供的锁-synchronized关键字的使用与实现。 通过本篇文章，你将了解到： 1、synchronized 如何使用 2、synchronized 源码初探 3、总结 1、synchronized 如何使用 多线程访问临界区 由上篇文章可知，多线程访问临界区需要锁： 临界区可以是一段代码，也可以是某个方法。 synchronized 各种使用方式 按锁作用区域划分，可分
Hotspot synchronized与volatile关键字实现（一） 源码解析
菜鸟进阶之路
03-16 1916
一、synchronized用法 1、修饰实例方法 2、修饰静态方法 3、修饰代码块 二、synchronized底层实现 1、修改代码块的字节码分析 2、monitorenter 指令实现 3、InterpreterRuntime::monitorenter 4、monitorexit 指令实现 5、InterpreterRuntime::monitorexit 6、monitorenter/ monitorexit 指令的编译执行
Hotspot 三种锁实现总结
菜鸟进阶之路
03-28 2707
目录 一、BasicObjectLock / BasicLock 二、偏向锁 三、轻量级锁 四、重量级锁 六、整体加锁流程 七、整体解锁流程 Java6对synchronized关键字进行了大幅度的优化，引入偏向锁和轻量级锁的概念，大幅减少了获得锁和释放锁的性能损耗。从Java6开始，加上原有的重量级锁（又叫监视器锁），Java中的对象锁一共有4种状态，分别是：无锁状...
Java 并发
hebeind100的博客
08-28 172
意点 了解 Java 中的基本线程间通讯的方式 了解 Java 中的 volatile 的基本语义 了解 C/C++ 编程 了解 JNI 的相关开发知识 了解一些 x86 的汇编（仅仅是很简单的内容，要求能读懂） 本文重点分析内容： 共享内存多核系统基本架构与设计 Java 内存模型设计 Java Thread 的创建与停止 Java synchonized 的实现机制 Java Object 的 wait 和 notify/notifyAll 实现机制 Java volatil
解析java第3章答案,一线开发大牛带你深度解析探讨模板解释器，解释器的生成...
weixin_32349699的博客
03-11 189
解释器生成解释器的机器代码片段都是在TemplateInterpreterGenerator::generate_all()中生成的，下面将分小节详细展示该函数的具体细节，以及解释器某个组件的机器代码生成过程与逻辑。与第4章不同的是，本节中的各部分出现的顺序与它们在代码中的顺序不一致。在研究解释器前了解调试手段是有必要的。由于运行时生成的机器代码是人类不可读的二进制形式，要想阅读它们，可以下载hs...
微调jvm源码，实现执行流在clion自由下断
ckiuick的博客
08-31 434
修改jvm源码，方便断点。
java check word lock_Java中synchronized与ReentrantLock性能对比
weixin_33897085的博客
03-04 135
前两天逛博客的时候看到有个人写了一篇博客说ReentrantLock比synchronized慢，这就很违反我的认知了，详细看了他的博客和测试代码，发现了他测试的不严谨，并在评论中友好地指出了他的问题，结果他直接把博客给删了 删了 了……很多老一辈的程序猿对有synchronized有个 性能差 的刻板印象，然后极力推崇使用java.util.concurrent包中的lock类，如果你追问他们s...
深入底层讲解：从 Synchronized 到锁的优化全过程解析
欢迎您访问我的公众号【前程有光】
03-15 391
我们知道 Synchronized 是 Java 中解决并发问题的一种最常用的方法, 也是最简单的一种方法. 被也被称为内置锁. Synchronized 的作用主要有三个： 确保线程互斥的访问同步代码 保证共享变量的修改能够及时可见 有效解决重排序问题。 从语法上讲, Synchronized 总共有三种用法: 修饰普通方法, 锁是当前实例对象. 修饰静态方法, 锁是当前类的 class 对象. 修饰代码块, 锁是括号中的对象. 关于使用方式, 这里就不再进行一一描述了. 我们直接进入正题, 看.
Hotspot 本地方法绑定与执行 源码解析
菜鸟进阶之路
12-01 981
目录 一、InterpreterGenerator::generate_native_entry 二、Methodnative_function 1、定义 2、set_native_function和clear_native_function 3、jni_RegisterNatives和jni_UnregisterNatives 4、NativeLookup::lookup ...
HotSpot运行时系统关键概念解析
Java提供了synchronized关键字和锁对象来实现线程安全。 **线程管理** HotSpot VM管理线程的创建、调度、同步和销毁。线程管理包括线程栈、上下文切换和线程局部存储。 **C++堆管理** C++堆主要用来存储非Java对象...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值