【Java并发编程】synchronized详解

深入解析Java中的synchronized关键字 接下来是偏向锁,我们还是用同样的代码即可,需要注意的是偏向锁必须在jvm启动后的一段时间才会运行,所以如果我们想打印偏向锁必须让线程休眠那么几秒,这里笔者就偷懒了一下,通过设置jvm参数。打印结果如下,我们只需关注第一行的object header,可以看到第一列的00000001,我们看到后3位为001,偏向锁标记为0,锁标记为01,001这就是我们说的无锁状态。上文讲解锁升级的之后,我们一直在说对象头的概念,所以为了能够直观的看到锁对象中对象头锁标记和锁状态的变化,我们这里引入一个jol工具。 阅读详情
AI摘要

本文详细解析了Java中synchronized关键字的实现原理,包括其在字节码层面的体现,以及在JVM源码中monitorenter和monitorexit指令的具体实现流程。探讨了synchronized在不同场景下的锁升级机制,如偏向锁、轻量级锁到重量级锁的转换。

一、synchronized简介

1.1 synchronized 的使用

synchronized关键字最主要有以下3种应用方式:

  • 修饰实例方法,作用于当前实例加锁,进入同步代码前要获得当前实例的锁 ;
  • 修饰静态方法,作用于当前类对象加锁,进入同步代码前要获得当前类对象的锁 ;
  • 修饰代码块,指定加锁对象,对给定对象加锁,进入同步代码库前要获得给定对象的锁。

1.2 synchronized 在jdk1.6中的 4 个优化

早期JDK对synchronized的实现是重量级的,其底层是由操作系统的 mutex lock 提供的,每一次的获取锁都需要进行用户态和内核态的切换,这是非常消耗系统资源和性能的。

在JDK1.6中对锁进行了优化,核心优化方案如下:

1.2.1 锁膨胀/锁升级

锁膨胀是指 synchronized 从 无锁——>偏向锁——>轻量级锁——>重量级锁 的过程,它叫做锁膨胀也叫做锁升级。

JDK 1.6 之前,synchronized 是重量级锁,也就是说 synchronized 在释放和获取锁时都会从用户态转换成内核态,而转换的效率是比较低的。但有了锁膨胀机制之后,synchronized 的状态就多了无锁、偏向锁以及轻量级锁了,这时候在进行并发操作时,大部分的场景都不需要用户态到内核态的转换了,这样就大幅的提升了 synchronized 的性能。

1.2.2 锁消除

锁消除指的是在某些情况下,JVM 虚拟机如果检测不到某段代码被共享和竞争的可能性,就会将这段代码所属的同步锁消除掉,从而到底提高程序性能的目的。

锁消除的依据是逃逸分析的数据支持,如 StringBuffer#append() 方法,或 Vector#add() 方法,在很多情况下是可以进行锁消除的,比如以下这段代码:

public String method() {
    StringBuffer sb = new StringBuffer();
    for (int i = 0; i < 10; i++) {
        sb.append("i:" + i);
    }
    return sb.toString();
}

编译后的字节码如下:

从上述结果可以看出,之前我们写的线程安全的加锁的 StringBuffer 对象,在生成字节码之后就被替换成了不加锁不安全的 StringBuilder 对象了,原因是 StringBuffer 的变量属于一个局部变量,并且不会从该方法中逃逸出去,所以此时我们就可以使用锁消除(不加锁)来加速程序的运行。

1.2.3 锁粗化

锁粗化是指,将多个连续的加锁、解锁操作连接在一起,扩展成一个范围更大的锁。

我只听说锁“细化”可以提高程序的执行效率,也就是将锁的范围尽可能缩小,这样在锁竞争时,等待获取锁的线程才能更早的获取锁,从而提高程序的运行效率,但锁粗化是如何提高性能的呢?

没错,锁细化的观点在大多数情况下都是成立了,但是一系列连续加锁和解锁的操作,也会导致不必要的性能开销,从而影响程序的执行效率,比如这段代码:

public String method() {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < 10; i++) {
        // 伪代码:加锁操作
        sb.append("i:" + i);
        // 伪代码:解锁操作
    }
    return sb.toString();
}

这里我们不考虑编译器优化的情况,如果在 for 循环中定义锁,那么锁的范围很小,但每次 for 循环都需要进行加锁和释放锁的操作,性能是很低的;但如果我们直接在 for 循环的外层加一把锁,那么对于同一个对象操作这段代码的性能就会提高很多,如下伪代码所示:

public String method() {
    StringBuilder sb = new StringBuilder();
    // 伪代码:加锁操作
    for (int i = 0; i < 10; i++) {
        sb.append("i:" + i);
    }
    // 伪代码:解锁操作
    return sb.toString();
}

锁粗化的作用:如果检测到同一个对象执行了连续的加锁和解锁的操作,则会将这一系列操作合并成一个更大的锁,从而提升程序的执行效率。

1.2.4 自适应自旋锁

自旋锁是指通过自身循环,尝试获取锁的一种方式,伪代码实现如下:

public class SpinLockDemo {

    // 现在的泛型装的是Thread,原子引用线程
    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    public void myLock() {
        // 获取当前进来的线程
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName() + "\t come in ");
        // 开始自旋,期望值是null,更新值是当前线程,如果是null,则更新为当前线程;否则自旋
        while(!atomicReference.compareAndSet(null, thread)) {
            System.out.println(Thread.currentThread().getName() + "正在自旋=====");
        }
    }

    /**
     * 解锁
     */
    public void myUnLock() {
        // 获取当前进来的线程
        Thread thread = Thread.currentThread();
        // 自己用完了后,把atomicReference变成null
        atomicReference.compareAndSet(thread, null);
        System.out.println(Thread.currentThread().getName() + "\t invoked myUnlock()");
    }
}

自旋锁优点在于它避免一些线程的挂起和恢复操作,因为挂起线程和恢复线程都需要从用户态转入内核态,这个过程是比较慢的,所以通过自旋的方式可以一定程度上避免线程挂起和恢复所造成的性能开销。

但是,如果长时间自旋还获取不到锁,那么也会造成一定的cpu资源浪费,所以我们通常会给自旋设置一个固定的值来避免一直自旋的性能开销。然而对于 synchronized 关键字来说,它的自旋锁更加的“智能”,synchronized 中的自旋锁是自适应自旋锁。

【自适应自旋锁】 :线程自旋的次数不再是固定的值,而是一个动态改变的值,这个值会根据前一次自旋获取锁的状态来决定此次自旋的次数。比如上一次通过自旋成功获取到了锁,那么这次通过自旋也有可能会获取到锁,所以这次自旋的次数就会增多一些,而如果上一次通过自旋没有成功获取到锁,那么这次自旋可能也获取不到锁,所以为了避免资源的浪费,就会少循环或者不循环,以提高程序的执行效率。简单来说,如果线程自旋成功了,则下次自旋的次数会增多,如果失败,下次自旋的次数会减少。

二、 synchronized原理

synchronized 的语义底层是通过一个monitor的对象来完成

要理解 sychronized 首先要了解 对象头的MarkWord 和 管程Monitor,在 上文《多线程基础知识》《偏向锁/轻量级锁/重量级锁详解》中已经介绍过了。

Java 虚拟机中的同步(Synchronization)基于进入和退出管程(Monitor)对象实现, 无论是显式同步 (有明确的 monitorenter 和 monitorexit 指令,即同步代码块) 还是隐式同步都是如此。在 Java 语言中,同步用的最多的地方可能是被 synchronized 修饰的同步方法。同步方法 并不是由 monitorenter 和 monitorexit 指令来实现同步的,而是由方法调用指令读取运行时常量池中方法的 ACC_SYNCHRONIZED 标志来隐式实现的。

  • 同步代码块:显式同步,有明确的 monitorenter 和 monitorexit 指令。
  • 同步方法:隐式同步,由方法调用指令读取运行时常量池中方法的 ACC_SYNCHRONIZED 标志。

2.1 synchronized 代码块字节码

现在我们定义一个 synchronized 修饰的同步代码块,在代码块中操作共享变量i,如下:

public class SyncCodeBlock {

   public int i;

   public void syncTask(){
       //同步代码库
       synchronized (this){
           i++;
       }
   }
}

编译上述代码并使用【javap -c -verbose ByteCodeTest.class】 反编译后得到字节码如下(这里我们省略一部分没有必要的信息):

也可以使用 IDEA 中的插件 【jclasslib Bytecode Viewer】,使用时直接选择 View --> Show Bytecode With jclasslib : 

Classfile /Users/zejian/Downloads/Java8_Action/src/main/java/com/zejian/concurrencys/SyncCodeBlock.class
  Last modified 2017-6-2; size 426 bytes
  MD5 checksum c80bc322c87b312de760942820b4fed5
  Compiled from "SyncCodeBlock.java"
public class com.zejian.concurrencys.SyncCodeBlock
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
  //........省略常量池中数据
  //构造函数
  public com.zejian.concurrencys.SyncCodeBlock();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 7: 0
  //===========主要看看syncTask方法实现================
  public void syncTask();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=3, locals=3, args_size=1
         0: aload_0
         1: dup
         2: astore_1
         3: monitorenter  //注意此处,进入同步方法
         4: aload_0
         5: dup
         6: getfield      #2             // Field i:I
         9: iconst_1
        10: iadd
        11: putfield      #2            // Field i:I
        14: aload_1
        15: monitorexit   //注意此处,退出同步方法
        16: goto          24
        19: astore_2
        20: aload_1
        21: monitorexit //注意此处,退出同步方法
        22: aload_2
        23: athrow
        24: return
      Exception table:
      //省略其他字节码.......
}
SourceFile: "SyncCodeBlock.java"

 我们主要关注字节码中的如下代码:

3: monitorenter  //进入同步方法
//..........省略其他  
15: monitorexit   //退出同步方法
16: goto          24
//省略其他.......
21: monitorexit //退出同步方法

2.2 synchronized 方法字节码

方法级的同步是隐式,即无需通过字节码指令来控制的,它实现在方法调用和返回操作之中。JVM可以从方法常量池中的方法表结构(method_info Structure) 中的 ACC_SYNCHRONIZED 访问标志区分一个方法是否同步方法。

当方法调用时,调用指令将会 检查方法的 ACC_SYNCHRONIZED 访问标志是否被设置,如果设置了,执行线程需要先竞争持有对象锁,即该对象对应的 monitor(虚拟机规范中用的是管程一词), 然后再执行方法,最后在方法执行完成(无论是正常完成还是非正常完成)时释放 monitor 。

在方法执行期间,执行线程持有了 monitor,其他任何线程都无法再获得同一个 monitor。如果一个同步方法执行期间抛出了异常,并且在方法内部无法处理此异常,那这个同步方法所持有的 monitor 将在异常抛到同步方法之外时自动释放。下面我们看看字节码层面如何实现:

public class SyncMethod {

   public int i;

   public synchronized void syncTask(){
           i++;
   }
}

使用javap反编译后的字节码如下:

Classfile /Users/zejian/Downloads/Java8_Action/src/main/java/com/zejian/concurrencys/SyncMethod.class
  Last modified 2017-6-2; size 308 bytes
  MD5 checksum f34075a8c059ea65e4cc2fa610e0cd94
  Compiled from "SyncMethod.java"
public class com.zejian.concurrencys.SyncMethod
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool;

   //省略没必要的字节码
  //==================syncTask方法======================
  public synchronized void syncTask();
    descriptor: ()V
    //方法标识ACC_PUBLIC代表public修饰,ACC_SYNCHRONIZED指明该方法为同步方法
    flags: ACC_PUBLIC, ACC_SYNCHRONIZED
    Code:
      stack=3, locals=1, args_size=1
         0: aload_0
         1: dup
         2: getfield      #2                  // Field i:I
         5: iconst_1
         6: iadd
         7: putfield      #2                  // Field i:I
        10: return
      LineNumberTable:
        line 12: 0
        line 13: 10
}
SourceFile: "SyncMethod.java"

从字节码中可以看出,synchronized 修饰的方法并没有 monitorenter 指令和 monitorexit 指令,取得代之的是 ACC_SYNCHRONIZED 标识,该标识指明了该方法是一个同步方法,JVM通过该 ACC_SYNCHRONIZED 访问标志来辨别一个方法是否声明为同步方法,从而执行相应的同步调用。

2.3 synchronized底层源码——monitorenter指令

1. JVM源码下载 http://openjdk.java.net/ Mercurial --> jdk8 --> hotspot --> zip

2. IDE(Clion)下载 https://www.jetbrains.com/ 

  • Monitor:openjdk\hotspot\src\share\vm\runtime\objectMonitor.hpp
  • MarkWord:openjdk\hotspot\src\share\vm\oops\markOop.hpp
  • monitorenter|exit指令:openjdk\hotspot\\src\share\vm\interpreter\interpreterRuntime.cpp
  • 偏向锁:openjdk\hotspot\src\share\vm\runtime\biasedLocking.cpp

在虛拟机执行到 monitorenter 指令时,首先要尝试获取对象的锁,即获取该对象对应的 monitor 的所有权。源码中会调用InterpreterRuntime.cpp (位于:src/share/vm/interpreter/interpreterRuntime.cpp) 的 InterpreterRuntime::monitorenter 函数。具体代码可参见HotSpot源码:

#InterpreterRuntime.cpp
IRT_ENTRY_NO_ASYNC(void, InterpreterRuntime::monitorenter(JavaThread* thread, BasicObjectLock* elem))
#ifdef ASSERT
  thread->last_frame().interpreter_frame_verify_monitor(elem);
#endif
  if (PrintBiasedLockingStatistics) {
    Atomic::inc(BiasedLocking::slow_path_entry_count_addr());
  }
  Handle h_obj(thread, elem->obj());
  assert(Universe::heap()->is_in_reserved_or_null(h_obj()),
         "must be NULL or an object");
  //是否使用偏向锁
  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);
  }
  assert(Universe::heap()->is_in_reserved_or_null(elem->obj()),
         "must be NULL or an object");
#ifdef ASSERT
  thread->last_frame().interpreter_frame_verify_monitor(elem);
#endif
IRT_END

2.3.1 ObjectSynchronizer::fast_enter 走偏向锁的逻辑

如果支持偏向锁,则执行 ObjectSynchronizer::fast_enter 走偏向锁的逻辑,源码实现在 synchronizer.cpp文件中,代码如下:

void ObjectSynchronizer::fast_enter(Handle obj, BasicLock* lock, bool attempt_rebias, TRAPS) {
 //判断是否开启了偏向锁
 if (UseBiasedLocking) { 
     //如果不处于全局安全点
    if (!SafepointSynchronize::is_at_safepoint()) {
      //通过`revoke_and_rebias`这个函数尝试获取偏向锁
      BiasedLocking::Condition cond = BiasedLocking::revoke_and_rebias(obj, attempt_rebias, THREAD);
      //如果是撤销与重偏向直接返回
      if (cond == BiasedLocking::BIAS_REVOKED_AND_REBIASED) {
        return;
      }
    } else {//如果在安全点,撤销偏向锁
      assert(!attempt_rebias, "can not rebias toward VM thread");
      BiasedLocking::revoke_at_safepoint(obj);
    }
    assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
 }

 slow_enter (obj, lock, THREAD) ;
}

流程如下:

  • 再次检查偏向锁是否开启,如果未开启:
    • 当处于不安全点时,通过 revoke_and_rebias() 尝试获取偏向锁,如果成功则直接返回,如果失败则进入轻量级锁获取过程。revoke_and_rebias() 这个偏向锁的获取逻辑在 biasedLocking.cpp中。
    • 当处于安全点时,撤销偏向锁。
  • 如果偏向锁未开启,则进入 slow_enter() 获取轻量级锁的流程。
2.3.1.1 BiasedLocking::revoke_and_rebias 函数——偏向锁获取逻辑
BiasedLocking::Condition BiasedLocking::revoke_and_rebias(Handle obj, bool attempt_rebias, TRAPS) {
  assert(!SafepointSynchronize::is_at_safepoint(), "must not be called while at safepoint");
  markOop mark = obj->mark(); //获取锁对象的对象头
  //判断mark是否为可偏向状态,即mark的偏向锁标志位为1,锁标志位为 01,线程id为null
  if (mark->is_biased_anonymously() && !attempt_rebias) {
    //这个分支是进行对象的hashCode计算时会进入,在一个非全局安全点进行偏向锁撤销
    markOop biased_value       = mark;
    //创建一个非偏向的markword
    markOop unbiased_prototype = markOopDesc::prototype()->set_age(mark->age());
    //Atomic:cmpxchg_ptr是CAS操作,通过cas重新设置偏向锁状态
    markOop res_mark = (markOop) Atomic::cmpxchg_ptr(unbiased_prototype, obj->mark_addr(), mark);
    if (res_mark == biased_value) {//如果CAS成功,返回偏向锁撤销状态
      return BIAS_REVOKED;
    }
  } else if (mark->has_bias_pattern()) {//如果锁对象为可偏向状态(biased_lock:1, lock:01,不管线程id是否为空),尝试重新偏向
    Klass* k = obj->klass(); 
    markOop prototype_header = k->prototype_header();
    //如果已经有线程对锁对象进行了全局锁定,则取消偏向锁操作
    if (!prototype_header->has_bias_pattern()) {
      markOop biased_value       = mark;
      //CAS 更新对象头markword为非偏向锁
      markOop res_mark = (markOop) Atomic::cmpxchg_ptr(prototype_header, obj->mark_addr(), mark);
      assert(!(*(obj->mark_addr()))->has_bias_pattern(), "even if we raced, should still be revoked");
      return BIAS_REVOKED; //返回偏向锁撤销状态
    } else if (prototype_header->bias_epoch() != mark->bias_epoch()) {
      //如果偏向锁过期,则进入当前分支
      if (attempt_rebias) {//如果允许尝试获取偏向锁
        assert(THREAD->is_Java_thread(), "");
        markOop biased_value       = mark;
        markOop rebiased_prototype = markOopDesc::encode((JavaThread*) THREAD, mark->age(), prototype_header->bias_epoch());
        //通过CAS 操作, 将本线程的 ThreadID 、时间错、分代年龄尝试写入对象头中
        markOop res_mark = (markOop) Atomic::cmpxchg_ptr(rebiased_prototype, obj->mark_addr(), mark);
        if (res_mark == biased_value) { //CAS成功,则返回撤销和重新偏向状态
          return BIAS_REVOKED_AND_REBIASED;
        }
      } else {//不尝试获取偏向锁,则取消偏向锁
        //通过CAS操作更新分代年龄
        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) { //如果CAS操作成功,返回偏向锁撤销状态
          return BIAS_REVOKED;
        }
      }
    }
  }
  ...//省略
}
2.3.1.2 BiasedLocking::revoke_at_safepoint——偏向锁撤销逻辑

当到达一个全局安全点时,这时会根据偏向锁的状态来判断是否需要撤销偏向锁,调用 BiasedLocking::revoke_at_safepoint 函数,这个方法也是在 BiasedLocking.cpp 中定义的,具体实现如下:

void BiasedLocking::revoke_at_safepoint(Handle h_obj) {
  assert(SafepointSynchronize::is_at_safepoint(), "must only be called while at safepoint");
  oop obj = h_obj();
  //更新撤销偏向锁计数,并返回偏向锁撤销次数和偏向次数
  HeuristicsResult heuristics = update_heuristics(obj, false);
  if (heuristics == HR_SINGLE_REVOKE) {//可偏向且未达到批量处理的阈值(下面会单独解释)
    revoke_bias(obj, false, false, NULL); //撤销偏向锁
  } else if ((heuristics == HR_BULK_REBIAS) || 
             (heuristics == HR_BULK_REVOKE)) {//如果是多次撤销或者多次偏向
    //批量撤销
    bulk_revoke_or_rebias_at_safepoint(obj, (heuristics == HR_BULK_REBIAS), false, NULL);
  }
  clean_up_cached_monitor_info();
}

偏向锁的释放,需要等待全局安全点(在这个时间点上没有正在执行的字节码),首先暂停拥有偏向锁的线程,然后检查持有偏向锁的线程是否还活着,如果线程不处于活动状态,则将对象头设置成无锁状态(ThreadID设置为NULL)。如果线程仍然活着,则会升级为轻量级锁,遍历偏向对象的所记录。栈帧中的锁记录和对象头的Mark Word要么重新偏向其他线程,要么恢复到无锁,或者标记对象不适合作为偏向锁。最后唤醒暂停的线程。

在上一节我们知道,JVM内部为每个类维护了一个偏向锁撤销计数器,对偏向锁撤销进行计数,当这个值达到指定阈值时,JVM会认为这个类的偏向锁有问题,需要重新偏向(rebias),对所有属于这个类的对象进行重偏向的操作成为 批量重偏向(bulk rebias)。在做bulk rebias时,会对这个类的epoch的值做自增,这个 epoch 会存储在对象头中的 epoch 字段。

判断这个对象是否获得偏向锁的条件是:

1. 对象头中markword的锁状态标志位为101;

2. ThreadID和当前线程id相等

3. 锁对象头中 mark word 的 epoch 字段和方法区 InstanceClass 中 _protype_header 的epoch值相同。如果epoch的值不一样,说明该对象的偏向锁已经无效了。

2.3.2 ObjectSynchronizer::slow_enter 走轻量级锁的逻辑

如果不支持偏向锁,则执行 ObjectSynchronizer::slow_enter 走轻量级锁的逻辑,该方法同样位于 synchronizer.cpp 文件中,代码如下:

void ObjectSynchronizer::slow_enter(Handle obj, BasicLock* lock, TRAPS) {
  markOop mark = obj->mark();
  assert(!mark->has_bias_pattern(), "should not see bias pattern here");

  if (mark->is_neutral()) {//如果当前是无锁状态,直接加轻量级锁
    //直接把markword保存到栈帧中BasicLock(LockRecord)对象的_displaced_header中
    lock->set_displaced_header(mark);
    //通过CAS将mark word更新为指向栈帧中BasicLock(LockRecord)对象的指针,更新成功表示获得了轻量级锁
    if (mark == (markOop) Atomic::cmpxchg_ptr(lock, obj()->mark_addr(), mark)) {
      TEVENT (slow_enter: release stacklock) ;
      return ;
    }
    // Fall through to inflate() ...
  } 
  //如果markword处于加锁状态、且markword中的ptr指针指向当前线程的栈帧,表示为重入操作,不需要争抢锁
  else
  if (mark->has_locker() && THREAD->is_lock_owned((address)mark->locker())) {
    assert(lock != mark->locker(), "must not re-lock the same lock");
    assert(lock != (BasicLock*)obj->mark(), "don't relock with same BasicLock");
    lock->set_displaced_header(NULL);
    return;
  }

#if 0
  // The following optimization isn't particularly useful.
  if (mark->has_monitor() && mark->monitor()->is_entered(THREAD)) {
    lock->set_displaced_header (NULL) ;
    return ;
  }
#endif
	//代码执行到这里,说明有多个线程竞争轻量级锁,轻量级锁通过`inflate`进行膨胀升级为重量级锁
  lock->set_displaced_header(markOopDesc::unused_mark());
  ObjectSynchronizer::inflate(THREAD, obj())->enter(THREAD);
}

简单整理轻量级锁的获取逻辑:

  • 如果markword处于无锁状态(001):
    • 直接把markword保存到栈帧中BasicLock(LockRecord)对象的_displaced_header中;
    • 通过CAS将markword更新为指向栈帧中BasicLock(LockRecord)对象的指针,更新成功表示获得了轻量级锁;
  • 如果当前markword处于加锁状态(000),且mark中的 ptr 指针指向当前线程的栈帧(锁重入),则执行同步代码;否则说明有多个线程竞争轻量级锁,轻量级锁需要膨胀升级为重量级锁。

2.3.3 轻量级锁膨胀为重量级锁——ObjectSynchronizer::inflate 函数

回顾之前的分析:

  • 偏向锁升级为轻量级锁时要修改Mark Word,使之指向 Lock Record;
  • 轻量级锁升级为重量级锁时也需要修改 Mark Word,使之指向 ObjectMonitor。

而创建/获取 ObjectMonitor 对象的过程即是锁的膨胀过程。

我们继续跟进 ObjectSynchronizer::inflate 函数,该方法描述了轻量级锁膨胀为重量级锁的过程(创建/获取 ObjectMonitor 对象的过程),源码如下:

#synchronizer.cpp
ObjectMonitor * ATTR ObjectSynchronizer::inflate (Thread * Self, oop object) {
  ...
  //死循环,直到获取到ObjectMonitor为止
  for (;;) {
      //取出Mark Word
      const markOop mark = object->mark() ;
      //如果是重量级锁
      if (mark->has_monitor()) {
          //是重量级锁,说明肯定已经有现成的ObjectMonitor,直接用就好了
          ObjectMonitor * inf = mark->monitor() ;
          return inf ;
      }

      //正在膨胀的时候
      if (mark == markOopDesc::INFLATING()) {
        //继续循环,需要等待膨胀完成
         continue ;
      }

      //如果当前是轻量级锁
      if (mark->has_locker()) {
          //分配ObjectMonitor对象
          ObjectMonitor * m = omAlloc (Self) ;
          //初始化一些参数
          m->Recycle();
          m->_Responsible  = NULL ;
          m->OwnerIsThread = 0 ;
          m->_recursions   = 0 ;
          m->_SpinDuration = ObjectMonitor::Knob_SpinLimit ;   // Consider: maintain by type/class

          //尝试将Mark Word更改为膨胀状态,此时Mark Word 全是0 --------->(1)
          //可能会有多线程走到这,因此用CAS
          markOop cmp = (markOop) Atomic::cmpxchg_ptr (markOopDesc::INFLATING(), object->mark_addr(), mark) ;
          if (cmp != mark) {
             //修改失败,继续循环
             omRelease (Self, m, true) ;
             continue ;       // Interference -- just retry
          }

          //若是修改成功,则取出之前轻量级锁存储的Mark Word
          markOop dmw = mark->displaced_mark_helper() ;
          //将Mark Word 搬到ObjectMonitor的_header字段里
          m->set_header(dmw) ;

          //_owner指向Lock Record,也就是设置锁的持有者是Lock Record------->(2)
          m->set_owner(mark->locker());
          //指向对象头
          m->set_object(object);
          //将Mark Word 指向ObjectMonitor------->(3)
          object->release_set_mark(markOopDesc::encode(m));
          ...
          //成功,则返回ObjectMonitor 对象
          return m ;
      }

      //无锁状态
      ObjectMonitor * m = omAlloc (Self) ;
      //初始化一些参数
      m->Recycle();
      //直接记录mark
      m->set_header(mark);
      //_owner为空-------------------->(4)
      m->set_owner(NULL);
      m->set_object(object);
      m->OwnerIsThread = 1 ;
      m->_recursions   = 0 ;
      m->_Responsible  = NULL ;
      m->_SpinDuration = ObjectMonitor::Knob_SpinLimit ;       // consider: keep metastats by type/class

      //将Mark Word修改为指向ObjectMonitor的指针-------------------->(5)
      if (Atomic::cmpxchg_ptr (markOopDesc::encode(m), object->mark_addr(), mark) != mark) {
          ...
          //失败,则重新尝试
          continue ;
      }
      ...
      //成功,则返回ObjectMonitor 对象
      return m ;
  }
}

上述代码即为简化过的膨胀流程,标注了5个重点:

  1. 如果当前锁是轻量级锁,说明有线程正在持有该锁,尝试CAS修改锁为膨胀状态。
  2. _owner不指向任何线程,指向的是Lock Reocrd,后续会有相应的判断。
  3. 轻量级锁时 MarkWord 存储着指向 Lock Record 的指针,而此时变为指向重量级锁的指针,也就是指向 ObjectMonitor 的指针。此处是单线程操作,因此可以直接设置。
  4. 如果当前锁是无锁状态,将_owner置空。
  5. CAS尝试将 Mark Word 指向ObjectMonitor。

69d11b815a4f445fbc124cc612443585.png

2.3.4 重量级锁加锁过程——ObjectMonitor::enter 函数

在调用 ObjectSynchronizer::inflate 函数完成膨胀,获取 ObjectMonitor 对象后,会调用 ObjectMonitor::enter(位于:src/share/vm/runtime/objectMonitor.cpp)函数完成重量级锁的加锁,源码如下:

2.3.4.1 ObjectMonitor::enter——初次尝试加锁(monitor竞争)

初次获取锁在 ObjectMonitor::enter 函数的实现:

#ObjectMonitor.cpp
void ATTR ObjectMonitor::enter(TRAPS) {
  //当前线程
  Thread * const Self = THREAD ;
  void * cur ;

  //尝试CAS修改_owner字段为当前线程,也就是尝试获取锁
  cur = Atomic::cmpxchg_ptr (Self, &_owner, NULL) ;
  if (cur == NULL) {
    //修改成功,则获取了重量级锁
     return ;
  }

  //以下都是CAS失败后的处理
  //如果当前_owner值为当前线程,则认为是重入了该锁
  if (cur == Self) {
    //重入次数+1,成功获取了锁
     _recursions ++ ;
     return ;
  }

  //_owner值为Lock Record,说明当前线程是之前轻量级锁的持有者
  if (Self->is_lock_owned ((address)cur)) {
    //重入次数为1次
    _recursions = 1 ;
    //改为当前线程
    _owner = Self ;
    OwnerIsThread = 1 ;
    return ;
  }
  ...

  { 
    ...
    for (;;) {
      //没有获取到锁,则执行该函数
      EnterI (THREAD) ;
      ...
      _recursions = 0 ;
      _succ = NULL ;
      exit (false, Self) ;
      jt->java_suspend_self();
    }
  }
}

由上可知,enter(xx) 函数主要做了如下事情:

  • 先CAS尝试修改 ObjectMonitor 的 _owner 字段,会有几种结果:
    • 1、锁没被其它线程占用,当前线程成功获取锁。
    • 2、锁被当前线程占用,当前线程重入该锁,获取锁成功,重入次数_recursions++。
    • 3、锁被 LockRecord 占用(轻量级锁),而LockRecord又属于当前线程,属于重入,重入次数_recursions为1。
    • 4、以上条件都不满足,调用 EnterI() 函数。

 8d198e993de74c5e888c9ff3a1e9c57c.png

2.3.4.2 ObjectMonitor::EnterI()——再次尝试加锁(monitor等待)

初次获取锁失败后,会走到下面的流程,也就是 ObjectMonitor::EnterI 函数的实现(位于:src/share/vm/runtime/ObjectMonitor.cpp):

#ObjectMonitor.cpp
void ATTR ObjectMonitor::EnterI (TRAPS) {
    //当前线程
    Thread * Self = THREAD ;
    //尝试加锁----------->(1)
    if (TryLock (Self) > 0) {
        return ;
    }
    //尝试自旋加锁----------->(2)
    if (TrySpin (Self) > 0) {
        return ;
    }
    //构造ObjectWaiter 节点
    ObjectWaiter node(Self) ;
    //挂起/唤醒线程重置参数
    Self->_ParkEvent->reset() ;
    //前驱节点为无效节点
    node._prev   = (ObjectWaiter *) 0xBAD ;
    //当前节点状态为CXQ,也就是说节点在_cxq队列里
    node.TState  = ObjectWaiter::TS_CXQ ;

    ObjectWaiter * nxt ;
    for (;;) {
        node._next = nxt = _cxq ;
        //将节点插入_cxq队列的头----------->(3)
        if (Atomic::cmpxchg_ptr (&node, &_cxq, nxt) == nxt) break ;

        //尝试获取锁----------->(4)
        if (TryLock (Self) > 0) {
            return ;
        }
    }
    ...
    for (;;) {
        //再次尝试获取锁----------->(5)
        if (TryLock (Self) > 0) break ;

        if ((SyncFlags & 2) && _Responsible == NULL) {
           Atomic::cmpxchg_ptr (Self, &_Responsible, NULL) ;
        }
        //挂起线程----------->(6)
        if (_Responsible == Self || (SyncFlags & 1)) {
            //挂起有超时时间
            Self->_ParkEvent->park ((jlong) RecheckInterval) ;
        } else {
            //挂起没有超时时间
            Self->_ParkEvent->park() ;
        }
        //唤醒后再次获取锁,成功则退出循环----------->(7)
        if (TryLock(Self) > 0) break ;
        //...还是一些自旋策略
    }
    //将节点从_cxq或_EntryList里移除----------->(8)
    UnlinkAfterAcquire (Self, &node) ;
    ...
    return ;
}

c87f1d1d1ab54c6d85f0b29953b80dec.png

ObjectMonitor::EnterI 函数主要做了如下事情:

  1. TryLock (Self) 尝试加锁(通过CAS将锁对象的 ObjectMonitor 内的 _owner 字段设置为当前线程);
  2. TrySpin (Self) 尝试自旋加锁(TrySpin里多次调用TryLock,次数是10次;源码里指出经验值20-100可能最佳);
  3. 如果仍然没有获取到锁,进入死循环,直到插入cxq队列成功或者获取了锁:
    1. 将该线程封装成一个 ObjectWaiter 对象 CAS 插入到 cxq(单向链表)队列的队首,修改 _cxq 指向当前节点,成功则break跳出循环。
    2. 插入队列失败,再次调用 TryLock (Self) 尝试获取锁,成功则直接return结束。
  4. 进入下一个死循环,先调用 TryLock (Self) 尝试获取锁;
  5. 若仍旧获取锁失败,则线程放弃获取锁的动作,调用 park() 将自己挂起,线程阻塞于此处,等待别的线程唤醒它。
  6. 当某个线程唤醒在(5)被挂起的线程后,被唤醒的线程立即调用 TryLock (Self) 再次尝试获取锁,如果还是失败了,则继续回到(4)的死循环。
  7. 获取锁成功后,因为前边已经加入到队列了,因此需要将节点从队列(cxq/EntryList)移除。

 977bc81d3123439eaf44989868e20d27.png

2.4 synchronized底层源码——monitorexit指令

在虛拟机执行到 monitorexit 指令释放锁时,源码中会调用InterpreterRuntime.cpp (位于:src/share/vm/interpreter/interpreterRuntime.cpp) 的 InterpreterRuntime::monitorexit 函数。具体代码可参见HotSpot源码:

#InterpreterRuntime.cpp
IRT_ENTRY_NO_ASYNC(void, InterpreterRuntime::monitorexit(JavaThread* thread, BasicObjectLock* elem))
#ifdef ASSERT
  thread->last_frame().interpreter_frame_verify_monitor(elem);
#endif
  Handle h_obj(thread, elem->obj());
  assert(Universe::heap()->is_in_reserved_or_null(h_obj()),
         "must be NULL or an object");
  if (elem == NULL || h_obj()->is_unlocked()) {
    THROW(vmSymbols::java_lang_IllegalMonitorStateException());
  }
  ObjectSynchronizer::slow_exit(h_obj(), elem->lock(), thread);
  // Free entry. This must be done here, since a pending exception might be installed on
  // exit. If it is not cleared, the exception handling code will try to unlock the monitor again.
  elem->set_obj(NULL);
#ifdef ASSERT
  thread->last_frame().interpreter_frame_verify_monitor(elem);
#endif
IRT_END

这段代码中主要是通过 ObjectSynchronizer::slow_exit 来执行,具体实现如下:

void ObjectSynchronizer::slow_exit(oop object, BasicLock* lock, TRAPS) {
  fast_exit (object, lock, THREAD) ;
}

ObjectSynchronizer::fast_exit的代码如下:

void ObjectSynchronizer::fast_exit(oop object, BasicLock* lock, TRAPS) {
  assert(!object->mark()->has_bias_pattern(), "should not see bias pattern here");
  // if displaced header is null, the previous enter is recursive enter, no-op
  markOop dhw = lock->displaced_header(); //获取锁对象中的对象头
  markOop mark ;
  if (dhw == NULL) { 
     // Recursive stack-lock.
     // Diagnostics -- Could be: stack-locked, inflating, inflated.
     mark = object->mark() ;
     assert (!mark->is_neutral(), "invariant") ;
     if (mark->has_locker() && mark != markOopDesc::INFLATING()) {
        assert(THREAD->is_lock_owned((address)mark->locker()), "invariant") ;
     }
     if (mark->has_monitor()) {
        ObjectMonitor * m = mark->monitor() ;
        assert(((oop)(m->object()))->mark() == mark, "invariant") ;
        assert(m->is_entered(THREAD), "invariant") ;
     }
     return ;
  }

  mark = object->mark() ; //获取线程栈帧中锁记录(LockRecord)中的markword

  // If the object is stack-locked by the current thread, try to
  // swing the displaced header from the box back to the mark.
  if (mark == (markOop) lock) {
     assert (dhw->is_neutral(), "invariant") ;
     //通过CAS尝试将Displaced Mark Word替换回对象头,如果成功,表示锁释放成功。
     if ((markOop) Atomic::cmpxchg_ptr (dhw, object->mark_addr(), mark) == mark) {
        TEVENT (fast_exit: release stacklock) ;
        return;
     }
  }
  //锁膨胀,调用重量级锁的释放锁方法
  ObjectSynchronizer::inflate(THREAD, object)->exit (true, THREAD) ;
}

2.4.1 重量级锁释放过程

上面分析了加锁的过程,它有两种结果:

  1. 成功获取锁,那么可以执行临界区代码。
  2. 获取锁失败,挂起等待别人唤醒。

关于2思考一个问题:是谁唤醒了它,如何唤醒的?由下源码可知:当前占有锁的线程释放锁后会唤醒阻塞等待锁的线程。

先来看看1,线程执行完临界区代码后需要释放锁,偏向锁和轻量级锁的释放上篇文章已经分析:若是释放失败,则会走到重量级锁的释放流程。重量级锁的释放流程,也就是 ObjectMonitor::exit 函数的实现(位于:src/share/vm/runtime/ObjectMonitor.cpp):

#ObjectMonitor.cpp
void ATTR ObjectMonitor::exit(bool not_suspended, TRAPS) {
   Thread * Self = THREAD ;
   //释放锁的线程不一定是重量级锁的获得者-------->(1)
   if (THREAD != _owner) {
     if (THREAD->is_lock_owned((address) _owner)) {
       //释放锁的线程是轻量级锁的获得者,先占用锁
       _owner = THREAD ;
     } else {
       //异常情况
       return;
     }
   }

   if (_recursions != 0) {
      //是重入锁,简单标记后退出
     _recursions--;
     return ;
   }
   ...

   for (;;) {
      if (Knob_ExitPolicy == 0) {
         //默认走这里
         //释放锁,别的线程可以抢占了
         OrderAccess::release_store_ptr (&_owner, NULL) ;   // drop the lock
         OrderAccess::storeload() ;                         // See if we need to wake a successor
         //如果没有线程在_cxq/_EntryList等待,则直接退出
         if ((intptr_t(_EntryList)|intptr_t(_cxq)) == 0 || _succ != NULL) {
            TEVENT (Inflated exit - simple egress) ;
            return ;
         }
         //有线程在等待,再把之前释放的锁拿回来
         if (Atomic::cmpxchg_ptr (THREAD, &_owner, NULL) != NULL) {
            //若是失败,说明被人抢占了,直接退出
            return ;
         }
      } else {
         ...
      }

      ObjectWaiter * w = NULL ;
      int QMode = Knob_QMode ;
      //此处省略代码
      //根据QMode不同,选不同的策略,主要是操作_cxq和_EntryList的方式不同
      //默认QMode=0

      w = _EntryList  ;
      if (w != NULL) {
         //_EntryList不为空,则释放锁---------(2)
          ExitEpilog (Self, w) ;
          return ;
      }

      //_EntryList 为空,则看_cxq有没有数据
      w = _cxq ;
      if (w == NULL) continue ;//没有继续循环

      for (;;) {
          //将_cxq头节点置空
          ObjectWaiter * u = (ObjectWaiter *) Atomic::cmpxchg_ptr (NULL, &_cxq, w) ;
          if (u == w) break ;
          w = u ;
      }
      if (QMode == 1) {
         ...
      } else {
         // QMode == 0 or QMode == 2
         //_EntryList指向_cxq
         _EntryList = w ;
         ObjectWaiter * q = NULL ;
         ObjectWaiter * p ;
         //该循环的目的是为了将_EntryList里的节点前驱连接起来---------(3)
         for (p = w ; p != NULL ; p = p->_next) {
             guarantee (p->TState == ObjectWaiter::TS_CXQ, "Invariant") ;
             //改为ENTER状态
             p->TState = ObjectWaiter::TS_ENTER ;
             p->_prev = q ;
             q = p ;
         }
      }

      w = _EntryList  ;
      if (w != NULL) {
          //释放锁---------(4)
          ExitEpilog (Self, w) ;
          return ;
      }
   }
}

当线程释放锁时,会从 cxq 或 EntryList 中挑选一个线程唤醒(根据「唤醒策略」,默认从 EntryList 的 Head 取),被选中的线程叫做 Heir presumptive (即假定继承人),就是上图中的 OnDeck(Ready Thread),假定继承人被唤醒后会尝试获得锁,但 synchronized 是非公平的,所以假定继承人不一定能获得锁(这也是它叫"假定"继承人的原因)。

  • 如果 _owner 不是当前线程(判断当前是不是持有锁的线程):
    • 若当前线程是之前持有轻量级锁的线程(由轻量级锁膨胀后还没调用过 enter 方法,此时_owner会是指向 Lock Record 的指针),则_owner改为指向当前线程,然后继续执行后面代码。
    • 否则异常情况,即当前不是持有锁的线程,抛出异常。
  • 如果_recursions (重入计数器) -1 后还不为0(还是重入),则返回继续执行程序代码。
  • 如果_recursions (重入计数器) -1 后为0,则释放锁(即设置owner为null),这个时刻其他的线程能获取到锁。
  • 如果当前没有线程在_cxq/_EntryList等待,则直接退出,因为不需要唤醒其他线程;或者如果 succ不为null,代表当前已经有个"醒着的"继承人线程OnDeck,那当前线程不需要唤醒任何线程,直接退出。
  • 根据 QMode 的不同,会执行不同的「唤醒策略」(QMode默认为0)
    • QMode = 2且 cxq 非空:取 cxq 队列队首的 ObjectWaiter 对象,调用 ExitEpilog() 方法,然后立即返回。【ExitEpilog (Self, w) :释放锁,将_owner置空;然后唤醒节点里ObjectWaiter对象封装的线程】
    • QMode = 3且 cxq 非空:把 cxq 队列插入到 EntryList 的 尾部;继续往下执行。
    • QMode = 4且 cxq 非空:把 cxq 队列插入到 EntryList 的头部;继续往下执行。
    • QMode = 0(默认):暂时什么都不做,继续往下(QMode默认是0);只有QMode=2的时候会提前返回,等于0、3、4的时候都会继续往下执行解锁流程:
      • 如果 EntryList 的首元素非空,就取出来调用 ExitEpilog() 方法,该方法会唤醒 ObjectWaiter 对象的线程(在 EnterI() 方法中调用 park() 挂起的线程),然后立即返回;
      • 如果 EntryList 的首元素为空,就将 cxq 的所有元素放入到 EntryList 中,然后再从 EntryList 中取出来队首元素执行 ExitEpilog 方法,然后立即返回;

Qmode=0(默认策略) 的判断逻辑就是先判断 Entrylist 是否为空:如果不为空,则取出第一个唤醒;如果为空再从 cxq 里面获取第一个唤醒。

Object#notify 方法唤醒线程后,线程会从 waitSet 移动到 EntryList ,线程最开始获取失败锁时总是在 _cxq 中,后再往 EntryList 中移动,所以 notify() 唤醒的线程会比普通线程获取锁的线程前执行。

 9d7c12ea63644e03a21002ccb637af72.png

Java synchronized(详细) 在Java中,`synchronized`关键字用于解决多线程并发访问共享资源时可能出现的线程安全问题。 阅读详情

相关推荐

【Java并发】synchronized

回答锁消除是 JVM 的优化手段:JIT 编译器检测到某些同步代码块的锁对象不存在共享竞争(如局部对象、逃逸分析判定为线程私有),会自动移除锁,减少性能开销。回答JVM 设定偏向锁批量撤销阈值为 40 次,是「性能权衡」的结果,回答synchronized 是 Java 并发的核心考点,面试答题需遵循「先定义→再原理→再场景→最后优化基础层:3 种用法+锁对象,避免基础用法错误;原理层:Mark Word+Monitor+锁升级,理解底层实现;优化层。

完全体 1120

Java同步synchronized

一. synchronized是什么? synchronized是Java的一个关键字,synchronized依赖于JVM具体实现。 synchronized的作用 synchronized也称为同步锁。synchronized是一种独占锁。 synchronized的两大功能: 内存可见性 操作原子性 什么是内存可见性? 可见性是指当多个线程访问同一个变量时,一个线程修改了这个变量的值,其他线程能够立即看得到修改的值。 可参考《Java内存分级和指令重排序》。volatile也可实现内存

joedan0104的专栏 5908

手把手教你搞定6脚三位一体数码管的驱动(附C语言源码与Visual Studio调试技巧)

本文详细解析了6脚三位一体数码管的驱动原理与实战技巧,包括引脚复用、动态扫描时序、Visual Studio模拟调试及单片机实现。通过C语言源码示例和调试技巧,帮助开发者快速掌握非标准数码管的驱动方法,提升硬件开发效率。

weixin_30613727的博客 594

Java多线程(二)——synchronized 详解

java多线程

m0_45198397的博客 5336

【Flink】状态编程: 订单超时告警

文章目录一、基础概念二、Flink状态编程1、支持的状态类型2、Managed Keyed State六种类型基本API状态的生命周期3、Managed Operator State三、案例:订单延迟告警统计1、需求描述2、需求分析3、数据与模型4、详细实现 一、基础概念 在Flink架构体系中,有状态计算可以说是Flink非常重要的特性之一。 有状态计算是指: 在程序计算过程中,在Flink...

一只皮皮熊 2868

网络攻防实验——网络监听

利用CAIN实现ARP监听。

Trieyes_of_feng的博客 3197

Java 并发编程中的 synchronized 锁详解

是 Java 中实现线程安全的一个重要工具,它能够有效地防止多个线程同时访问共享资源导致的数据不一致问题。然而,也存在性能开销和死锁风险,因此在实际开发中,需要合理设计和使用。对于简单的线程安全需求,可以直接使用。对于复杂的并发场景,应该考虑使用更灵活的工具,如Atomic等。

萌萌白白的博客 826

carsim与simulink联合仿真学习笔记(二)——使用C-class车模做driver model仿真(5 driver sensors)

Driver model 在carsim的Simulink库中自带外部驾驶员模型,打开后如图所示: 然后打开carsim中对应的数据集,如图所示: 具体仿真步骤不在赘述,注意到这里选择的是E-Class车模,那么如果我想选择C-Class车型进行仿真呢?点三角选择车型可以看到: 马赛克部分是我后来建的,如过没有使用过是没有马赛克部分的。那么既然这里没有C-class,又该怎么办呢? 创建C-...

xufuqiang2017的博客 4123

Java并发编程:synchronized详解

在当今的软件开发领域,高并发已经成为一个不可忽视的关键问题。尤其是在处理大量用户请求或进行资源密集型操作时,如何确保程序的稳定性和效率显得尤为重要。以一个典型的场景为例,假设我们正在开发一个在线购物平台,当用户进行购物操作时,系统需要处理大量的并发请求,如商品查询、购物车更新、订单支付等。在这种情况下,如果不妥善处理并发问题,可能会导致数据不一致、系统崩溃等问题。因此,掌握Java中的高并发知识点,尤其是synchronized关键字,对于开发高效、稳定的程序至关重要。

AIHacksCash的博客 815

RK3588部署rtmpose模型

摘要: 本文详细介绍了在RK3588开发板上部署RTMPose模型的全流程。首先在Ubuntu环境中搭建MMCV框架,通过MMPose工具将PTH模型转换为ONNX格式。随后使用RKNN-Toolkit2将ONNX模型转换为RKNN格式,并完成开发板部署。关键步骤包括模型转换(PTH→ONNX→RKNN)、环境配置和推理验证,最终实现人体姿态估计功能。整个过程涉及MMPose、RKNN-Toolkit等工具链的使用,为边缘计算场景下的实时姿态分析提供了可行方案。

qq_44224801的博客 1222

ThinkAdmin后台Getshell

通过文件包含或者图片马的方式Getshell。修改其可允许的文件类型,php不允许,可添加。系统管理->系统参数配置->本地服务器存储。

hot_milk1的博客 1870

synchronized 详解 (Java 并发编程核心)

摘要: synchronized是Java实现线程安全的核心机制,通过内置锁(Monitor)保证共享资源的互斥访问。作用范围包括同步实例方法(锁为当前对象)、同步静态方法(锁为Class对象)及同步代码块(需指定锁对象)。其特性包含互斥性、可重入性及内存可见性。JVM底层通过monitorenter/monitorexit指令实现,并优化为偏向锁、轻量级锁和重量级锁。使用时需注意性能开销、死锁风险及锁粒度控制,建议最小化临界区、谨慎选择锁对象(避免使用String或包装类)并优先使用同步代码块。复杂场景可

csdn_tom_168的博客 935

MEMS传感器技术深度解析:从原理到未来趋势的全面指南(智能驾驶赛道有戏)

在智能汽车每秒产生1GB数据的今天,在可穿戴设备厚度突破1毫米的极限挑战下,MEMS(微机电系统)传感器正以的三大核心优势,重塑着人类感知世界的方式。作为从业10年的MEMS工程师,我见证了这个领域从实验室走向量产的完整历程——从2005年汽车安全气囊中笨重的压阻式加速度计,到2025年智能手机中集成5种传感器的SoC芯片,MEMS技术正在书写传感器行业的摩尔定律新篇章。本文将带您穿透技术迷雾,深入解析MEMS传感器的技术密码,涵盖,并附独家整理的与。文末更提供,助您把握万亿级市场机遇。

CSDN-新能源汽车研发测试专业博主 2303

Java并发编程——synchronized详解

介绍 synchronized 用处,三种使用方式及其原理

猫头夜鹰的小屋 479

【YOLO多模态检测顶刊】TGRS 2025范文解读,RGFNet 可见光-红外图像融合目标检测,2026年基于YOLO多模态融合属于发文热点,小论文和大论文通用,通读顶刊了解做实验和论文写作的全流程

🔥本文提出了一种反射率引导的渐进特征对齐网络(RGFNet)用于全天候无人机目标检测。该方法利用Retinex理论从可见光图像中提取光照不变的反射率特征,设计了反射率引导协同对齐模块(RCAM)实现跨模态双向特征对齐,并通过光照感知选择性融合模块(LSFM)在共享状态空间中进行高效特征交互。在DroneVehicle和DVTOD数据集上的实验表明,RGFNet分别达到81.4%和88.5%的mAP,显著优于现有方法。该方法有效解决了低光照条件下可见光-红外图像特征错位问题,为全天候无人机检测提供了新思路。

Ai缝合怪、助力小伙伴高效发论文 1085

vb 6.0并口开发操作实例

vb6并口开发,简体中文,试例内有inpout32.dll动态链接库

Java并发编程之synchronized详解

在Java多线程编程中,synchronized一直是元老级角色,很多人称呼它为重量级锁,但是随着Java SE1.6对其进行了各种优化之后,有些情况下它就不再那么重了,我们先看下利用synchronized实现同步的基础:Java中每一个对象都可以作为锁,具体表现为以下三种:1、对于普通同步方法,锁是当前实例对象;2、对于静态同步方法,锁是当前类的Class对象;3、对于同步方法块,锁是sync...

Stay Hungry, Stay Foolish 1948

全球国家地区城市数据

MySQL全球国家地区城市数据报。。。。。。。。。。。。

Java并发编程synchronized详解

1

qq_44146560的博客 562

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

【java】并发编程之synchronized详解

本文全面解析 Java 中的 synchronized 同步机制。首先通过计数器案例展示多线程并发问题,引出 synchronized 的必要性。详细讲解其三种使用方式:同步方法(锁当前实例对象)、同步代码块(推荐使用专用锁对象提升性能)和静态同步方法(锁 Class 对象)。重点分析了锁对象选择的业务场景,强调专用锁对象优于 synchronized(this) 的原因:避免意外竞争、减小锁粒度、提高代码清晰度。文章从实际应用到底层原理,帮助开发者正确使用 synchronized 保证线程安全。

2301_81481532的博客 492

Java并发编程-synchronized 原理详解

关键字在Java中通过JVM字节码的和指令实现。无论是在正常执行流程还是异常处理流程中,Java编译器都会确保监视器锁的正确获取和释放。这种机制通过反编译和观察JVM指令可以得到清晰的理解。Java语言规范JVM指令集手册。

WenZhang的博客 1262

【Java 并发编程】一文详解 Java 内置锁 synchronized

关键字 synchronized 可以保证在同一时刻,只有一个线程可以执行某个方法或某个代码块,同时可以保证一个线程的变化可见(可见性),即可以代替 volatile。关键字加到 static 静态方法和代码块上都是是给 Class 类上锁。关键字加到实例方法上是给对象实例上锁。/*** 提供一个私有的静态属性,对于 volatile 修饰的字段,可以防止指令重排/*** 提供一个私有构造函数:避免类在外部被实例化。

迪曼奥特迦-博客 1949
上一篇: 【Java并发编程】偏向锁/轻量级锁/重量级锁详解
下一篇: 用户态与内核态
叉烧钵钵鸡
博客等级 码龄11年 1201粉丝 36原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值
⌂ 换网址