openjdk11 jvm视角查看java线程异常退出synchronized锁自动释放

已于 2024-08-23 18:35:15 修改
阅读量204 收藏
点赞数 3
文章标签： jvm java 开发语言
于 2024-08-23 10:08:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014200244/article/details/141435807
版权

##synchronized锁异常 java代码demo

public class ThreadTest {

    public int mul = 1;

    public static void main(String[] args) {
        ThreadTest threadTest = new ThreadTest();
        Thread yym_user_thread1 = new Thread() {
            public void run() {
                System.out.println("yym_user_thread1");
                threadTest.resources(0);
            }
        };
        yym_user_thread1.setName("yym_user_thread1");
        yym_user_thread1.start();
        //
        //
        Thread.yield();Thread.yield();Thread.yield();
        Thread.yield();Thread.yield();Thread.yield();
        Thread yym_user_thread2 = new Thread() {
            public void run() {
                System.out.println("yym_user_thread2");
                threadTest.resources(1);
            }
        };
        yym_user_thread2.setName("yym_user_thread2");
        yym_user_thread2.start();
    }

    public  void resources(int number) {
        synchronized(this) {
            for (int i = 0; i < 10000; i++) {
                mul++;
            }
            int result = mul / number;
            System.out.println("resources" + result);
        }
    }

}

##javap -v ThreadTest 查看monitorenter monitorexit字节码

major version: 55
  flags: (0x0021) ACC_PUBLIC, ACC_SUPER
  this_class: #3                          // ThreadTest
  super_class: #17                        // java/lang/Object
  interfaces: 0, fields: 1, methods: 3, attributes: 4
{0x0000000705f0f9a0}Constant pool:
{0x0000000705f2dd10}   #1 = Methodref          #17.#34        // java/lang/Object."<init>":()V
   #2 = Fieldref           #3.#35         // ThreadTest.mul:I
{0x0000000705fc52e0}   #3 = Class              #36            // ThreadTest
   #4 = Methodref          #3.#34         // ThreadTest."<init>":()V
   #5 = Class              #37            // ThreadTest$1
   #6 = Methodref          #5.#38         // ThreadTest$1."<init>":(LThreadTest;)V
   #7 = String             #39            // yym_user_thread1
   #8 = Methodref          #40.#41        // java/lang/Thread.setName:(Ljava/lang/String;)V
   #9 = Methodref          #40.#42        // java/lang/Thread.start:()V
  #10 = Methodref          #40.#43        // java/lang/Thread.yield:()V
  #11 = Class              #44            // ThreadTest$2
  #12 = Methodref          #11.#38        // ThreadTest$2."<init>":(LThreadTest;)V
  #13 = String             #45            // yym_user_thread2
  #14 = Fieldref           #46.#47        // java/lang/System.out:Ljava/io/PrintStream;
{0x000000070610aa38}{0x0000000706114b80}{0x000000070613dfd0}  #15 = InvokeDynamic      #0:#51         // #0:makeConcatWithConstants:(I)Ljava/lang/String;
  #16 = Methodref          #52.#53        // java/io/PrintStream.println:(Ljava/lang/String;)V
  #17 = Class              #54            // java/lang/Object
  #18 = Utf8               InnerClasses
  #19 = Utf8               mul
  #20 = Utf8               I
  #21 = Utf8               <init>
  #22 = Utf8               ()V
  #23 = Utf8               Code
  #24 = Utf8               LineNumberTable
  #25 = Utf8               main
  #26 = Utf8               ([Ljava/lang/String;)V
  #27 = Utf8               resources
  #28 = Utf8               (I)V
  #29 = Utf8               StackMapTable
  #30 = Class              #55            // java/lang/Throwable
  #31 = Utf8               SourceFile
  #32 = Utf8               ThreadTest.java
  #33 = Utf8               NestMembers
  #34 = NameAndType        #21:#22        // "<init>":()V
  #35 = NameAndType        #19:#20        // mul:I
  #36 = Utf8               ThreadTest
  #37 = Utf8               ThreadTest$1
  #38 = NameAndType        #21:#56        // "<init>":(LThreadTest;)V
  #39 = Utf8               yym_user_thread1
  #40 = Class              #57            // java/lang/Thread
  #41 = NameAndType        #58:#59        // setName:(Ljava/lang/String;)V
  #42 = NameAndType        #60:#22        // start:()V
  #43 = NameAndType        #61:#22        // yield:()V
  #44 = Utf8               ThreadTest$2
  #45 = Utf8               yym_user_thread2
  #46 = Class              #62            // java/lang/System
  #47 = NameAndType        #63:#64        // out:Ljava/io/PrintStream;
  #48 = Utf8               BootstrapMethods
{0x0000000706184b20}  #49 = MethodHandle       6:#65          // REF_invokeStatic java/lang/invoke/StringConcatFactory.makeConcatWithConstants:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/invoke/CallSite;
  #50 = String             #66            // resources\u0001
  #51 = NameAndType        #67:#68        // makeConcatWithConstants:(I)Ljava/lang/String;
  #52 = Class              #69            // java/io/PrintStream
  #53 = NameAndType        #70:#59        // println:(Ljava/lang/String;)V
  #54 = Utf8               java/lang/Object
  #55 = Utf8               java/lang/Throwable
  #56 = Utf8               (LThreadTest;)V
  #57 = Utf8               java/lang/Thread
  #58 = Utf8               setName
  #59 = Utf8               (Ljava/lang/String;)V
  #60 = Utf8               start
  #61 = Utf8               yield
  #62 = Utf8               java/lang/System
  #63 = Utf8               out
  #64 = Utf8               Ljava/io/PrintStream;
  #65 = Methodref          #71.#72        // java/lang/invoke/StringConcatFactory.makeConcatWithConstants:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/invoke/CallSite;
  #66 = Utf8               resources\u0001
  #67 = Utf8               makeConcatWithConstants
  #68 = Utf8               (I)Ljava/lang/String;
  #69 = Utf8               java/io/PrintStream
  #70 = Utf8               println
  #71 = Class              #73            // java/lang/invoke/StringConcatFactory
  #72 = NameAndType        #67:#76        // makeConcatWithConstants:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/invoke/CallSite;
  #73 = Utf8               java/lang/invoke/StringConcatFactory
  #74 = Class              #78            // java/lang/invoke/MethodHandles$Lookup
  #75 = Utf8               Lookup
  #76 = Utf8               (Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/invoke/CallSite;
  #77 = Class              #79            // java/lang/invoke/MethodHandles
  #78 = Utf8               java/lang/invoke/MethodHandles$Lookup
  #79 = Utf8               java/lang/invoke/MethodHandles
{
  public int mul;
{0x00000007061ad120}    descriptor: I
    flags: (0x0001) ACC_PUBLIC

  public ThreadTest();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC
    Code:
{0x00000007061d5a80}{0x000000070601ee30}      stack=2, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: aload_0
         5: iconst_1
         6: putfield      #2                  // Field mul:I
         9: return
      LineNumberTable:
        line 1: 0
        line 3: 4

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC
    Code:
      stack=3, locals=4, args_size=1
         0: new           #3                  // class ThreadTest
         3: dup
         4: invokespecial #4                  // Method "<init>":()V
         7: astore_1
         8: new           #5                  // class ThreadTest$1
        11: dup
        12: aload_1
        13: invokespecial #6                  // Method ThreadTest$1."<init>":(LThreadTest;)V
        16: astore_2
        17: aload_2
        18: ldc           #7                  // String yym_user_thread1
        20: invokevirtual #8                  // Method java/lang/Thread.setName:(Ljava/lang/String;)V
        23: aload_2
        24: invokevirtual #9                  // Method java/lang/Thread.start:()V
        27: invokestatic  #10                 // Method java/lang/Thread.yield:()V
        30: invokestatic  #10                 // Method java/lang/Thread.yield:()V
        33: invokestatic  #10                 // Method java/lang/Thread.yield:()V
        36: invokestatic  #10                 // Method java/lang/Thread.yield:()V
        39: invokestatic  #10                 // Method java/lang/Thread.yield:()V
        42: invokestatic  #10                 // Method java/lang/Thread.yield:()V
        45: new           #11                 // class ThreadTest$2
        48: dup
        49: aload_1
        50: invokespecial #12                 // Method ThreadTest$2."<init>":(LThreadTest;)V
        53: astore_3
        54: aload_3
        55: ldc           #13                 // String yym_user_thread2
        57: invokevirtual #8                  // Method java/lang/Thread.setName:(Ljava/lang/String;)V
        60: aload_3
        61: invokevirtual #9                  // Method java/lang/Thread.start:()V
        64: return
      LineNumberTable:
        line 6: 0
        line 7: 8
        line 13: 17
        line 14: 23
        line 17: 27
        line 18: 36
        line 19: 45
        line 25: 54
        line 26: 60
        line 27: 64

  public void resources(int);
    descriptor: (I)V
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=3, locals=5, args_size=2
         0: aload_0
         1: dup
         2: astore_2
         3: monitorenter
         4: iconst_0
         5: istore_3
         6: iload_3
         7: sipush        10000
        10: if_icmpge     29
        13: aload_0
        14: dup
        15: getfield      #2                  // Field mul:I
        18: iconst_1
        19: iadd
        20: putfield      #2                  // Field mul:I
        23: iinc          3, 1
        26: goto          6
        29: aload_0
        30: getfield      #2                  // Field mul:I
        33: iload_1
        34: idiv
        35: istore_3
        36: getstatic     #14                 // Field java/lang/System.out:Ljava/io/PrintStream;
        39: iload_3
        40: invokedynamic #15,  0             // InvokeDynamic #0:makeConcatWithConstants:(I)Ljava/lang/String;
        45: invokevirtual #16                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        48: aload_2
        49: monitorexit
        50: goto          60
        53: astore        4
        55: aload_2
        56: monitorexit
        57: aload         4
        59: athrow
        60: return
      Exception table:
         from    to  target type
             4    50    53   any
            53    57    53   any
      LineNumberTable:
        line 30: 0
        line 31: 4
        line 32: 13
        line 31: 23
        line 34: 29
        line 35: 36
        line 36: 48
        line 37: 60
      StackMapTable: number_of_entries = 4
        frame_type = 253 /* append */
          offset_delta = 6
          locals = [ class java/lang/Object, int ]
        frame_type = 250 /* chop */
          offset_delta = 22
        frame_type = 87 /* same_locals_1_stack_item */
          stack = [ class java/lang/Throwable ]
        frame_type = 250 /* chop */
          offset_delta = 6
}
SourceFile: "ThreadTest.java"
NestMembers:
  ThreadTest$2
  ThreadTest$1
InnerClasses:
  #11;                                    // class ThreadTest$2
  #5;                                     // class ThreadTest$1
  public static final #75= #74 of #77;    // Lookup=class java/lang/invoke/MethodHandles$Lookup of class java/lang/invoke/MethodHandles
BootstrapMethods:
  0: #49 REF_invokeStatic java/lang/invoke/StringConcatFactory.makeConcatWithConstants:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/invoke/CallSite;
    Method arguments:
      #50 resources\u0001

##gdb线程栈  异常处理

(gdb) c
Continuing.
@@@@-yym-Thread PID: 4160
@@@@-yym-Thread NAME: yym_user_thread2
yym_user_thread2
[Switching to Thread 0x7fffc9d6c700 (LWP 4157)]

Thread 18 "C2 CompilerThre" hit Breakpoint 4, JavaThread::exit (this=0x7fffa4220800, destroy_vm=false, exit_type=JavaThread::normal_exit)
    at /home/yym/code/jdk11u-master/src/hotspot/share/runtime/thread.cpp:1917
1917      this->clear_pending_exception();
(gdb) c
Continuing.
[Switching to Thread 0x7fffc9b6a700 (LWP 4159)]

Thread 20 "yym_user_thread" hit Breakpoint 4, JavaThread::exit (this=0x7ffff07bd800, destroy_vm=false, exit_type=JavaThread::normal_exit)
    at /home/yym/code/jdk11u-master/src/hotspot/share/runtime/thread.cpp:1917
1917      this->clear_pending_exception();
(gdb) s
ThreadShadow::clear_pending_exception (this=0x7ffff07bd800) at /home/yym/code/jdk11u-master/src/hotspot/share/utilities/exceptions.cpp:59
59      void ThreadShadow::clear_pending_exception() {
(gdb) list
54        _pending_exception = exception;
55        _exception_file    = file;
56        _exception_line    = line;
57      }
58
59      void ThreadShadow::clear_pending_exception() {
60        LogTarget(Debug, exceptions) lt;
61        if (_pending_exception != NULL && lt.is_enabled()) {
62          ResourceMark rm;
63          LogStream ls(lt);
(gdb) n
60        LogTarget(Debug, exceptions) lt;
(gdb) p exception
No symbol "exception" in current context.
(gdb) n
61        if (_pending_exception != NULL && lt.is_enabled()) {

 ##抛出异常

##方法退出

 ##gdb调试

(gdb) b thread.cpp:1917

(gdb) p *_pending_exception
$8 = {_mark = 0x7ffff07bd805, _metadata = {_klass = 0xe294f72300014610, _compressed_klass = 83472}}
(gdb) call _pending_exception->print_on(tty)
java.lang.ArithmeticException
{0x0000000714a7b8f0} - klass: 'java/lang/ArithmeticException'
 - ---- fields (total size 5 words):
 - private transient 'backtrace' 'Ljava/lang/Object;' @12  a 'java/lang/Object'[5] {0x0000000714a7b918} (e294f723)
 - private 'detailMessage' 'Ljava/lang/String;' @16  "/ by zero"{0x0000000714a7b8b8} (e294f717)
 - private 'cause' 'Ljava/lang/Throwable;' @20  a 'java/lang/ArithmeticException'{0x0000000714a7b8f0} (e294f71e)
 - private 'stackTrace' '[Ljava/lang/StackTraceElement;' @24  a 'java/lang/StackTraceElement'[0] {0x0000000715120a70} (e2a2414e)
 - private strict 'suppressedExceptions' 'Ljava/util/List;' @28  a 'java/util/Collections$EmptyList'{0x000000071510bb90} (e2a21772)
 - private transient 'depth' 'I' @32  2
(gdb) bt
#0  ThreadShadow::clear_pending_exception (this=0x7ffff07bd800) at /home/yym/code/jdk11u-master/src/hotspot/share/utilities/exceptions.cpp:61
#1  0x00007ffff6173b7c in JavaThread::exit (this=0x7ffff07bd800, destroy_vm=false, exit_type=JavaThread::normal_exit)
    at /home/yym/code/jdk11u-master/src/hotspot/share/runtime/thread.cpp:1917
#2  0x00007ffff61738ef in JavaThread::thread_main_inner (this=0x7ffff07bd800) at /home/yym/code/jdk11u-master/src/hotspot/share/runtime/thread.cpp:1875
#3  0x00007ffff617374a in JavaThread::run (this=0x7ffff07bd800) at /home/yym/code/jdk11u-master/src/hotspot/share/runtime/thread.cpp:1850
#4  0x00007ffff616f8eb in Thread::call_run (this=0x7ffff07bd800) at /home/yym/code/jdk11u-master/src/hotspot/share/runtime/thread.cpp:387
#5  0x00007ffff5f703fd in thread_native_entry (thread=0x7ffff07bd800) at /home/yym/code/jdk11u-master/src/hotspot/os/linux/os_linux.cpp:827
#6  0x00007ffff71c56ba in start_thread (arg=0x7fffc9b6a700) at pthread_create.c:333
#7  0x00007ffff790051d in clone () at ../sysdeps/unix/sysv/linux/x86_64/clone.S:109
(gdb)

##yym_user_thread1释放锁

(gdb) set args ThreadTest
(gdb) handle SIGSEGV pass noprint nostop
Signal        Stop      Print   Pass to program Description
SIGSEGV       No        No      Yes             Segmentation fault
(gdb) handle SIGFPE pass noprint nostop
Signal        Stop      Print   Pass to program Description
SIGFPE        No        No      Yes             Arithmetic exception
(gdb) b thread.cpp:1917
(gdb) b ObjectMonitor::exit
(gdb)b ObjectMonitor::ExitEpilog

InterpreterRuntime::monitorexit (thread=0x7ffff06c6800, elem=0x7fffc9b695d8) at /home/yym/code/jdk11u-master/src/hotspot/share/interpreter/interpreterRuntime.cpp:801
801       elem->set_obj(NULL);
(gdb) n
803       thread->last_frame().interpreter_frame_verify_monitor(elem);
(gdb) n
788     IRT_ENTRY_NO_ASYNC(void, InterpreterRuntime::monitorexit(JavaThread* thread, BasicObjectLock* elem))
(gdb) p thread->print_on(tty)
"yym_user_thread1" #12 prio=5 os_prio=0 cpu=1.74ms elapsed=132.10s tid=0x00007ffff06c6800 nid=0x2163 runnable  [0x00007fffc9b69000]
   java.lang.Thread.State: RUNNABLE
   JavaThread state: _thread_in_vm
Thread: 0x00007ffff06c6800  [0x2163] State: _call_back _has_called_back 0 _at_poll_safepoint 0
   JavaThread state: _thread_in_vm
$7 = void
(gdb)

##唤醒其他线程

(gdb) n
[Switching to Thread 0x7fffc9b6a700 (LWP 9733)]

Thread 20 "yym_user_thread" hit Breakpoint 4, ObjectMonitor::ExitEpilog (this=0x7fffb0008b80, Self=0x7ffff072f000, Wakee=0x7fffc9a68600)
    at /home/yym/code/jdk11u-master/src/hotspot/share/runtime/objectMonitor.cpp:1283
1283      assert(_owner == Self, "invariant");
(gdb) n
1291      _succ = Knob_SuccEnabled ? Wakee->_thread : NULL;
(gdb) n
1292      ParkEvent * Trigger = Wakee->_event;

##main释放锁-等待日后验证，现阶段不知道干啥的

(gdb) b thread.cpp:2040

蚰蜒螟
关注
Java同步锁Synchronized底层源码和原理剖析
赵广陆
05-24 761
目录1 synchronized场景回顾2 反汇编寻找锁实现原理3 synchronized虚拟机源码3.1 HotSpot源码Monitor生成3.2 HotSpot源码之Monitor竞争3.3 HotSpot源码之Monitor等待3.4 HotSpot源码之Monitor释放 1 synchronized场景回顾 目标： synchronized回顾（锁分类–>多线程） 概念 synchronized：是Java中的关键字，是一种同步锁。 Java中锁分为以下几种： 乐观锁、悲观锁(syn)
java 线程锁的关键字,Java并发编程之Synchronized关键字
weixin_35512156的博客
03-14 239
并发编程的重点也是难点是数据同步、线程安全、锁。要编写线程安全的代码，其核心在于对共享和可变的状态的访问进行管理。共享意味着变量可以由多个线程访问，而可变则意味着变量的值在其生命周期内可以发生变化。当多个线程访问某个状态变量且其中有一个线程执行写入操作时，必须采用同步机制来协同这些线程对变量的访问。Java中的主要同步机制是关键字synchronized，它提供了一种独占的加锁方式。勾勾从一下几个...
Java多线程：synchronized | Volatile 和Lock和ReadWriteLock多方位剖析（一）
血煞长虹 的专栏
02-19 2268
本文较为系统，全面的介绍了在多线程中，synchronized理论和用法 | Lock和ReentrantLock Volatile 区别和联系，主要涉及常区分不清的理论，不涉及过深的源码剖析，是多线程爱好者不可多得的好文，点击进入一饱眼福吧！............
【java多线程】对象头、synchronized锁的升级、monitor
努力充实，远方可期
09-22 1982
很久之前写的一篇文章，简单整理了下发表出来。整理的不够好，但是内容很充分很多内容是长期积累的舍不得删了，读者尽量把前面的看懂吧。源码部分可忽略 一、对象头 在 JVM 中，对象在内存中分为三块区域： 对象头：标记字段和类型指针。一会介绍 实例数据：这部分主要是存放类的数据信息，父类的信息。 对齐填充：由于虚拟机要求对象起始地址必须是8字节的整数倍，填充数据不是必须存在的，仅仅是为了字节对齐。 HotSpot虚拟机中，设计了一个OOP&Klass Model。它用来标识一个对象的特征，注意并不包
Synchronized关键字深析（小白慎入，深入jvm源码，两万字长文）
热门推荐
Java新生代
04-07 8万+
从jvm层面解析synchronized，看完绝对可以超越绝大数人
JVM内置锁Synchronized关键字详解
沮丧的南瓜
05-28 488
一、设计同步器的意义 多线程编程中，有可能会出现多个线程同时访问同一个共享、可变资源的情况，这个资源我们称之其为临界资源；这种资源可能是：对象、变量、文件等。 共享：资源可以由多个线程同时访问 可变：资源可以在其生命周期内被修改 引出的问题： 由于线程执行的过程是不可控的，所以需要采用同步机制来协同对对象可变状态的访问！ 如何解决线程并发安全问题？ 实际上，所有的并发模式在解决线程安全问题时，采用的方案都是序列化访问临界资源。即在同一时刻，只能有一个线程访问临界资源，也称作同步互斥访问。 Java 中，提
java线程锁的状态_Java-synchronized 中锁的状态及其转换
weixin_29823011的博客
02-13 426
synchronized锁的优化过程：无锁 ->偏向锁 -> 轻量级锁 -> 重量级锁一、不同锁对象的状态表示(需要了解 Java 对象头)二、关于Lock Record(锁记录)当字节码解释器执行 monitorenter 字节码轻量级锁锁住一个对象时，就会在获取锁的线程的栈上显式或者隐式分配一个 Lock Record 空间。三、偏向锁在 JDK 1.6 中引入，默认启...
JVM对synchronized的优化——锁膨胀
蒋含竹的博客
12-27 2218
文章目录Java对synchronized的优化——锁膨胀前言锁标志位锁膨胀的流程 Java对synchronized的优化——锁膨胀 前言 通常我们在synchronized(…)中传一个对象，即可实现加锁，非常简单。而使用锁，常见的问题就是效率慢。在较早期的Java中synchronized会直接调用系统的重量级互斥锁(monitor)来实现加锁，效率较慢。锁膨胀则是针对该问题的优化方案：由...
Synchronized的原理和锁升级过程
weixin_44490796的博客
08-04 246
Synchronized的原理和升级过程 参考文献： Java精通并发-通过openjdk源码分析ObjectMonitor底层实现 - cexo - 博客园 (cnblogs.com) 由Java 15废弃偏向锁，谈谈Java Synchronized 的锁机制 - 云+社区 - 腾讯云 (tencent.com) ps：这是对知识点的归纳和自己的一些理解 如果有说的不对的地方，欢迎在评论去指出（侵删） 1、对象布局 首先，我们要知道对象在内存中的布局： 已知对象是存放在堆内存中的，对象大致可以分为三
【Java面试题汇总】JVM篇（2023版）
vincewm的博客
04-20 1万+
JVM内存模型、双亲委派模型、类加载机制、内存溢出、垃圾回收机制、内存泄漏、垃圾回收流程、垃圾回收器、G1、CMS、JVM调优
synchronized锁原理分析（一、从Java对象头看synchronized锁的状态）
12-21
为了查看Java对象的实际内存布局，可以利用如OpenJDK的JOL（Java Object Layout）工具。通过运行特定的Java代码，可以打印出对象在内存中的详细结构，从而了解MarkWord和Klass Pointer等信息。 总结来说，...
JAVA多线程之并发与同步，Lock与Syncronized
csdn_aiyang的博客
03-23 2万+
说到线程，就不得不先说线程和进程的关系。进程是系统的执行单位，一般一个应用程序即是一个进程，程序启动时系统默认有一个主线程，即是UI线程，我们知道不能做耗时任务，否则ANR程序无响应。这时需要借助子线程实现，即多线程。由于线程是系统CPU的最小单位，用多线程其实就是为了更好的利用cpu的资源。一、多线程创建方式//线程休眠1000毫秒，sleep使线程进入Block状态，并释放资源xx.start();//启动线程，run函数运行@Override@Override。
JNI-从jvm源码分析Thread.sleep、synchronized、LockSupport.park的线程阻塞的区别
m0_37125602的博客
11-22 808
前言 在日常编码的过程中，我们经常会使用Thread.sleep、LockSupport.park()主动阻塞线程，或者使用synchronized和Object.wait来阻塞线程保证并发安全。此时我们会发现，对于Thread.sleep和Object.wait方法是会抛出InterruptedException，而LockSupport.park()和synchronized则不会。而当我们调用Thread.interrupt方法时，除了synchronized，其他线程阻塞的方式都会被唤醒。 于是本文
【RabbitMQ——具体使用场景】
qq_45467608的博客
09-25 1242
串行方式：将订单信息写入数据库成功后，发送注册邮件，再发送注册短信。以上三个任务全部完成后，返回给客户端。
随笔 JVM本质
Pandaer杂货铺
09-25 910
当时的操作系统至少存在两个阵营，一个是Windows，一个是Linux，由于系统不同，提供的系统库API也不一样，这就导致在写C语言代码的时候，尤其使用到系统库的时候都不得不做兼容处理。那么它是如何做到的呢？文件加载进JVM进程中的元数据区，然后创建一个主线程，将这个字节码文件的main方法的地址赋值给这个线程的PC寄存器，然后这个主线程将PC寄存器的值交给执行引擎，执行引擎开始执行字节码指令，比如上面的代码，一开始就执行main方法，所以就会在栈空间上开辟一块新的栈帧，存放一些局部变量，这里便是字符串。
【JVM】双亲委派模型
Yeeear的博客
09-24 8579
之所以这个东西面试出场概率高高，最大的原因就是它起的名字很好听描述了查找.class文件的策略。
java中的强软弱虚
小天花藏
09-27 306
在java中对象的引用有强、软、弱、虚四种，这些引用级别的区别主要体现在对象的生命周期、回收时机的不同。
JVM基本组成
m0_72869421的博客
09-25 737
JVM使得Java程序可以在不同的操作系统上运行，而无需修改代码，这一点通过Java的“一次编写，到处运行”（Write Once, Run Anywhere）的理念得以实现。总的来说，JVM的设计和实现使得Java成为了一个功能强大、易于使用、安全可靠的编程语言，适用于各种规模的应用开发。：Java拥有丰富的标准类库和第三方库，以及强大的开发和调试工具，这使得开发者可以快速开发高质量的应用程序。：Java语言简洁明了，有着丰富的文档和社区支持，使得初学者容易上手，同时也满足了专业开发者的需求。
Java入门（基础，常见API，JVM，JUC并发编程）
最新发布
2301_76556912的博客
09-30 358
Java初学者软件安装与idea快捷键-CSDN博客 Java基本概念（新手入门）_阿伟java资料-CSDN博客JavaAPI-CSDN博客JVM入门-CSDN博客JUC并发编程-CSDN博客
JVM线程状态深度解析：Thread.sleep背后的实现与区别
当一个线程调用Thread.sleep时，它会释放锁并进入SLEEPING状态，这时它不会消耗CPU资源，直到被其他线程唤醒，然后重新获取锁并继续执行。 理解这些概念对于深入理解Java并发编程至关重要，因为它们涉及线程调度、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值