深入Java底层：内存屏障与JVM并发详解

内存屏障 又称内存栅栏 是一组处理器指令 用于实现对内存 *** 作的顺序限制 本文假定读者已经充分掌握了相关概念和Java内存模型 不讨论并发互斥 并行机制和原子性 内存屏障用来实现并发编程中称为可见性（visibility）的同样重要的作用

内存屏障为何重要？

对主存的一次访问一般花费硬件的数百次时钟周期 处理器通过缓存（caching）能够从数量级上降低内存延迟的成本这些缓存为了性能重新排列待定内存 *** 作的顺序 也就是说 程序的读写 *** 作不一定会按照它要求处理器的顺序执行 当数据是不可变的 同时/或者数据限制在线程范围内 这些优化是无害的

如果把这些优化与对称多处理（symmetric multi processing）和共享可变状态（shared mutable state）结合 那么就是一场噩梦 当基于共享可变状态的内存 *** 作被重新排序时 程序可能行为不定 一个线程写入的数据可能被其他线程可见 原因是数据 写入的顺序不一致 适当的放置内存屏障通过强制处理器顺序执行待定的内存 *** 作来避免这个问题

内存屏障的协调作用

内存屏障不直接由JVM暴露 相反它们被JVM插入到指令序列中以维持语言层并发原语的语义 我们研究几个简单Java程序的源代码和汇编指令 首先快速看一下Dekker算法中的内存屏障 该算法利用volatile变量协调两个线程之间的共享资源访问

请不要关注该算法的出色细节 哪些部分是相关的？每个线程通过发信号试图进入代码第一行的关键区域 如果线程在第三行意识到冲突（两个线程都要访问） 通 过turn变量的 *** 作来解决 在任何时刻只有一个线程可以访问关键区域

// code run by first thread     // code run by second thread

    intentFirst = true;          intentSecond = true;

    while (intentSecond)   while (intentFirst)       // volatile read

     if (turn != ) {      if (turn != ) {       // volatile read

       intentFirst = false;        intentSecond = false;

       while (turn != ) {}        while (turn != ) {}

       intentFirst = true;        intentSecond = true;

     }               }

    criticalSection();   criticalSection();

    turn = ;     turn = ;                 // volatile write

    intentFirst = false;   intentSecond = false;     // volatile write

硬件优化可以在没有内存屏障的情况下打乱这段代码 即使编译器按照程序员的想法顺序列出所有的内存 *** 作 考虑第三 四行的两次顺序volatile读 *** 作 每一个线程检查其他线程是否发信号想进入关键区域 然后检查轮到谁 *** 作了 考虑第 行的两次顺序写 *** 作 每一个线程把访问权释放给其他线程 然后撤销自己访问关键区域的意图 读线程应该从不期望在其他线程撤销访问意愿后观察到其他线程对turn变量的写 *** 作 这是个灾难

但是如果这些变量没有 volatile修饰符 这的确会发生！例如 没有volatile修饰符 第二个线程在第一个线程对turn执行写 *** 作（倒数第二行）之前可能会观察到 第一个线程对intentFirst(倒数第一行)的写 *** 作 关键词volatile避免了这种情况 因为它在对turn变量的写 *** 作和对 intentFirst变量的写 *** 作之间创建了一个先后关系 编译器无法重新排序这些写 *** 作 如果必要 它会利用一个内存屏障禁止处理器重排序 让我们来 看看一些实现细节

PrintAssembly HotSpot选项是JVM的一个诊断标志 允许我们获取JIT编译器生成的汇编指令 这需要最新的OpenJDK版本或者新HotSpot update 或者更高版本 通过需要一个反编译插件 Kenai项目提供了用于Solaris Linux和BSD的插件二进制文件 hsdis是另 一款可以在Windows通过源码构建的插件

两次顺序读 *** 作的第一次（第三行）的汇编指令如下 指令流基于Itanium 多处理硬件 JDK update 本文的所有指令流都在左手边以行号标记 相关的读 *** 作 写 *** 作和内存屏障指令都以粗体标记 建议读者不要沉迷于每一行指令

  x de c:      adds r = r ;;  ;

  x de a :      ld acq r =[r ];;  ; b a a

  x de a :      nop m x      ; c

  x de ac:      sxt r r =r ;;  ;

  x de b :      cmp eq p p = r   ; c

  x de b :      nop i x      ;

  x de bc:      nd dpnt many x de ;

简短的指令流其实内容丰富 第一次volatile位于第二行 Java内存模型确保了JVM会在第二次读 *** 作之前将第一次读 *** 作交给处理器 也就是按照 程序的顺序 但是这单单一行指令是不够的 因为处理器仍然可以自由乱序执行这些 *** 作 为了支持Java内存模型的一致性 JVM在第一次读 *** 作上添加了注解ld acq 也就是 载入获取 （load acquire） 通过使用ld acq 编译器确保第二行的读 *** 作在接下来的读 *** 作之前完成 问题就解决了

请注意这影响了读 *** 作 而不是写 内存屏障强制读或写 *** 作顺序限制不是单向的 强制读和写 *** 作顺序限制的内存屏障是双向的 类似于双向开的栅栏 使用ld acq就是单向内存屏障的例子

一致性具有两面性 如果一个读线程在两次读 *** 作之间插入了内存屏障而另外一个线程没有在两次写 *** 作之间添加内存屏障又有什么用呢？线程为了协调 必须同时 遵守这个协议 就像网络中的节点或者团队中的成员 如果某个线程破坏了这个约定 那么其他所有线程的努力都白费 Dekker算法的最后两行代码的汇编指令应该插入一个内存屏障 两次volatile写之间

$ java XX:+UnlockDiagnosticVMOptions XX:PrintAssemblyOptions=hsdis print bytes

XX:CompileCommand=print WriterReader write WriterReader

  x de c :      adds r = r ;;  ; b

  x de c :      st rel [r ]=r   ;

  x de cc:      adds r = r ;;  ;

  x de d :      st rel [r ]=r   ; a

  x de d :      mf            ;

  x de dc:      nop i x ;;   ;

  x de e :      mov r =r    ;

  x de e :      mov ret b =r x de e

  x de ec:      mov i ar pfs=r   ; aa

  x de f :      mov r =r     ;

这里我们可以看到在第四行第二次写 *** 作被注解了一个显式内存屏障 通过使用st rel 即 存储释放 （store release） 编译器确保第一次写 *** 作在第二次写 *** 作之前完成 这就完成了两边的约定 因为第一次写 *** 作在第二次写 *** 作之前发生

st rel屏障是单向的 就像ld acq一样 但是在第五行编译器设置了一个双向内存屏障 mf指令 或者称为 内存栅栏 是Itanium 指令集中的完整栅栏 笔者认为是多余的

内存屏障是特定于硬件的

本文不想针对所有内存屏障做一综述 这将是一件不朽的功绩 但是 重要的是认识到这些指令在不同的硬件体系中迥异 下面的指令是连续写 *** 作在多处理 Intel Xeon硬件上编译的结果 本文后面的所有汇编指令除非特殊声明否则都出自于Intel Xeon

  x f c: push   %ebp               ;

  x f d: sub    $ x %esp          ; ec

  x f : mov    $ x c %edi        ; bf c

  x f : movb   $ x x a f (%edi)  ; c d a af

  x f f: mfence                    ; faef

  x f : mov    $ x %ebp        ; bd

  x f : mov    $ x d %edx        ; ba d

  x f c: mov l x a f (%edx) %ebx  ; fbe a da af

  x f : test   %ebx %ebx          ; db

  x f : jne    x f          ;

  x f : movl   $ x x a f (%ebp)  ; c d a af

  x f : movb   $ x x a f (%edi)  ; c d a af

  x f : mfence                    ; faef

  x f b: add    $ x %esp          ; c

  x f e: pop    %ebp               ; d

我们可以看到x Xeon在第 行执行两次volatile写 *** 作 第二次写 *** 作后面紧跟着mfence *** 作 显式的双向内存屏障 下面的连续写 *** 作基于SPARC

xfb ecc : ldub  [ %l + x ] %l   ; e c

xfb ecc : cmp  %l                ; a e

xfb ecc c: bne pn   %icc xfb eccb   ;

xfb ecc : nop                       ;

xfb ecc : st  %l [ %l + x ]  ; e

xfb ecc : clrb  [ %l + x ]     ; c c

xfb ecc c: membar  #StoreLoad        ; e

xfb ecca : sethi  %hi( xff fc ) %l   ; fcff

xfb ecca : ld  [ %l ] %g           ; c

xfb ecca : ret                       ; c e

xfb eccac: restore                   ; e

我们看到在第五 六行存在两次volatile写 *** 作 第二次写 *** 作后面是一个membar指令 显式的双向内存屏障 x 和SPARC的指令流与Itanium的指令流存在一个重要区别 JVM在x 和SPARC上通过内存屏障跟踪连续写 *** 作 但是在两次写 *** 作之间没有放置内存屏障

另一方面 Itanium的指令流在两次写 *** 作之间存在内存屏障 为何JVM在不同的硬件架构之间表现不一？因为硬件架构都有自己的内 存模型 每一个内存模型有一套一致性保障 某些内存模型 如x 和SPARC等 拥有强大的一致性保障 另一些内存模型 如Itanium PowerPC和Alpha 是一种弱保障

例如 x 和SPARC不会重新排序连续写 *** 作 也就没有必要放置内存屏障 Itanium PowerPC和Alpha将重新排序连续写 *** 作 因此JVM必须在两者之间放置内存屏障 JVM使用内存屏障减少Java内存模型和硬件内存模型之间的距离

隐式内存屏障

显式屏障指令不是序列化内存 *** 作的唯一方式 让我们再看一看Counter类这个例子

class Counter{

    static int counter = ;

    public static void main(String[] _){

        for(int i = ; i < ; i++)

            inc();

    }

    static synchronized void inc(){ counter += ; }

}

Counter类执行了一个典型的读 修改 写的 *** 作 静态counter字段不是volatile的 因为所有三个 *** 作必须要原子可见的 因此 inc 方法是synchronized修饰的 我们可以采用下面的命令编译Counter类并查看生成的汇编指令 Java内存模型确保了synchronized区域的退出和volatile内存 *** 作都是相同的可见性 因此我们应该预料到会有另一个内存屏障

$ java XX:+UnlockDiagnosticVMOptions XX:PrintAssemblyOptions=hsdis print bytes

XX: UseBiasedLocking XX:CompileCommand=print Counter inc Counter

  x d eda : push   %ebp               ;

  x d eda : mov    %esp %ebp          ; bec

  x d edaa: sub    $ x %esp         ; ec

  x d edad: mov    $ x ba %esi   ; be ba

  x d edb : lea    x (%esp) %edi    ; d c

  x d edb : mov    %esi x (%edi)     ;

  x d edb : mov    (%esi) %eax        ; b

  x d edbb: or     $ x %eax          ; c

  x d edbe: mov    %eax (%edi)        ;

  x d edc : lock cmpxchg %edi (%esi)  ; f fb e

  x d edc : je     x d edda         ; f

  x d edca: sub    %esp %eax          ; bc

  x d edcc: and    $ xfffff %eax   ; e f ffff

  x d edd : mov    %eax (%edi)        ;

  x d edd : jne    x d ee          ; f

  x d edda: mov    $ x ba b %eax   ; b b ba

  x d eddf: mov    x (%eax) %esi   ; bb

  x d ede : inc    %esi               ;

  x d ede : mov    %esi x (%eax)   ; b

  x d edec: lea    x (%esp) %eax    ; d

  x d edf : mov    (%eax) %esi        ; b

  x d edf : test   %esi %esi          ; f

  x d edf : je     x d ee          ; f d

  x d edfa: mov    x (%eax) %edi     ; b

  x d edfd: lock cmpxchg %esi (%edi)  ; f fb

  x d ee : jne    x d ee f         ; f

  x d ee : mov    %ebp %esp          ; be

  x d ee : pop    %ebp               ; d

不出意外 synchronized生成的指令数量比volatile多 第 行做了一次增 *** 作 但是JVM没有显式插入内存屏障 相反 JVM通过在 第 行和第 行cmpxchg的lock前缀一石二鸟 cmpxchg的语义超越了本文的范畴

lock cmpxchg不仅原子性执行写 *** 作 也会刷新等待的读写 *** 作 写 *** 作现在将在所有后续内存 *** 作之前完成 如果我们通过ncurrent atomic AtomicInteger 重构和运行Counter 将看到同样的手段

import ncurrent atomic AtomicInteger;

    class Counter{

        static AtomicInteger counter = new AtomicInteger( );

        public static void main(String[] args){

            for(int i = ; i < ; i++)

                counter incrementAndGet();

        }

    }

$ java XX:+UnlockDiagnosticVMOptions XX:PrintAssemblyOptions=hsdis print bytes

XX:CompileCommand=print AtomicInteger incrementAndGet Counter

  x f : push   %ebp               ;

  x f : mov    %esp %ebp          ; bec

  x fa: sub    $ x %esp         ; ec

  x fd: jmp    x a         ; e

  x : xchg   %ax %ax            ;

  x : test   %eax xb e     ; e b

  x a: mov    x (%ecx) %eax     ; b

  x d: mov    %eax %esi          ; bf

  x f: inc    %esi               ;

  x : mov    $ x a f d %edi   ; bfd f a

  x : mov    x (%edi) %edi   ; bbf

  x b: mov    %ecx %edi          ; bf

  x d: add    $ x %edi          ; c

  x : lock cmpxchg %esi (%edi)  ; f fb

  x : mov    $ x %eax          ; b

  x : je     x          ; f

  x f: mov    $ x %eax          ; b

  x : cmp    $ x %eax          ; f

  x : je     x          ; cb

  x : mov    %esi %eax          ; bc

  x b: mov    %ebp %esp          ; be

  x d: pop    %ebp               ; d

我们又一次在第 行看到了带有lock前缀的写 *** 作 这确保了变量的新值（写 *** 作）会在其他所有后续内存 *** 作之前完成

内存屏障能够避免

JVM非常擅于消除不必要的内存屏障 通常JVM很幸运 因为硬件内存模型的一致性保障强于或者等于Java内存模型 在这种情况下 JVM只是简单地插 入一个no op语句 而不是真实的内存屏障

例如 x 和SPARC内存模型的一致性保障足够强壮以消除读volatile变量时所需的内存屏障 还记得在 Itanium上两次读 *** 作之间的显式单向内存屏障吗？x 上的Dekker算法中连续volatile读 *** 作的汇编指令之间没有任何内存屏障 x 平台上共享内存的连续读 *** 作

  x f : mov    $ x %ebp        ; bd

  x f : mov    $ x d %edx        ; ba d

  x f c: mov l x a f (%edx) %ebx  ; fbe a da af

  x f : test   %ebx %ebx          ; db

  x f : jne    x f          ;

  x f : movl   $ x x a f (%ebp)  ; c d a af

  x f : movb   $ x x a f (%edi)  ; c d a af

  x f : mfence                    ; faef

  x f b: add    $ x %esp          ; c

  x f e: pop    %ebp               ; d

  x f f: test   %eax xb ec     ; c eb

  x f : ret                       ; c

  x f : nopw   x (%eax %eax )   ; f f

  x f : mov    x a f (%ebp) %ebx  ; b d d a af

  x f : test   %edi xb ec     ; d c eb

第三行和第十四行存在volatile读 *** 作 而且都没有伴随内存屏障 也就是说 x 和SPARC上的volatile读 *** 作的性能下降对于代码的优 化影响很小 指令本身和常规读 *** 作一样

单向内存屏障本质上比双向屏障性能要好一些 JVM在确保单向屏障即可的情况下会避免使用双向屏障 本文的第一个例子展示了这点 Itanium平台上的 连续两次读 *** 作 入单向内存屏障 如果读 *** 作插入显式双向内存屏障 程序仍然正确 但是延迟比较长

动态编译

静态编译器在构建阶段决定的一切事情 在动态编译器那里都可以在运行时决定 甚至更多 更多信息意味着存在更多机会可以优化 例如 让我们看看JVM在单 处理器运行时如何对待内存屏障 以下指令流来自于通过Dekker算法实现两次连续volatile写 *** 作的运行时编译 程序运行于 x 硬件上的单处理器模式中的VMWare工作站镜像

  x b c: push   %ebp               ;

  x b d: sub    $ x %esp          ; ec

  x b : mov    $ x c %edi        ; bf c

  x b : movb   $ x x f (%edi)  ; c d aaf

  x b f: mov    $ x %ebp        ; bd

  x b : mov    $ x d %edx        ; ba d

  x b : mov l x f (%edx) %ebx  ; fbe a d aaf

  x b : test   %ebx %ebx          ; db

  x b : jne    x b          ; c

  x b : movl   $ x x f (%ebp)  ; c d aaf

  x b : add    $ x %esp          ; c

  x b : pop    %ebp               ; d

在单处理器系统上 JVM为所有内存屏障插入了一个no op指令 因为内存 *** 作已经序列化了 每一个写 *** 作（第 行）后面都跟着一个屏障 JVM针对原子条件式做了类似的优化 下面的指令流来自于同一 个VMWare镜像的AtomicInteger incrementAndGet动态编译结果

  x f : push   %ebp               ;

  x f : mov    %esp %ebp          ; bec

  x fa: sub    $ x %esp         ; ec

  x fd: jmp    x a         ; e

  x : xchg   %ax %ax            ;

  x : test   %eax xb b     ; bb

  x a: mov    x (%ecx) %eax     ; b

  x d: mov    %eax %esi          ; bf

  x f: inc    %esi               ;

  x : mov    $ x a f d %edi   ; bfd f a

  x : mov    x (%edi) %edi   ; bbf

  x b: mov    %ecx %edi          ; bf

  x d: add    $ x %edi          ; c

  x : cmpxchg %esi (%edi)       ; fb

  x : mov    $ x %eax          ; b

  x : je     x          ; f

  x e: mov    $ x %eax          ; b

  x : cmp    $ x %eax          ; f

  x : je     x          ; cc

  x : mov    %esi %eax          ; bc

  x a: mov    %ebp %esp          ; be

  x c: pop    %ebp               ; d

注意第 行的cmpxchg指令 之前我们看到编译器通过lock前缀把该指令提供给处理器 由于缺少SMP JVM决定避免这种成本 与静态编译有些不同

结束语

lishixinzhi/Article/program/Java/hx/201311/25723

[1]新生状态（New）：当一个线程的实例被创建即使用new关键字和Thread类或其子类创建一个线程对象后，此时该线程处于新生(new)状态，处于新生状态的线程有自己的内存空间，但该线程并没有运行，此时线程还不是活着的（notalive）。

[2]就绪状态（Runnable）：通过调用线程实例的start()方法来启动线程使线程进入就绪状态(runnable)；处于就绪状态的线程已经具备了运行条件，但还没有被分配到CPU即不一定会被立即执行，此时处于线程就绪队列，等待系统为其分配CPCU，等待状态并不是执行状态；此时线程是活着的（alive）。

[3]运行状态（Running）：一旦获取CPU(被JVM选中)，线程就进入运行(running)状态，线程的run()方法才开始被执行；在运行状态的线程执行自己的run()方法中的 *** 作，直到调用其他的方法而终止、或者等待某种资源而阻塞、或者完成任务而死亡；如果在给定的时间片内没有执行结束，就会被系统给换下来回到线程的等待状态；此时线程是活着的（alive）。

[4]阻塞状态（Blocked）：通过调用join()、sleep()、wait()或者资源被暂用使线程处于阻塞(blocked)状态；处于Blocking状态的线程仍然是活着的（alive）。

[5]死亡状态（Dead）：当一个线程的run()方法运行完毕或被中断或被异常退出，该线程到达死亡(dead)状态。此时可能仍然存在一个该Thread的实例对象，当该Thread已经不可能在被作为一个可被独立执行的线程对待了，线程的独立的callstack已经被dissolved。一旦某一线程进入Dead状态，他就再也不能进入一个独立线程的生命周期了。对于一个处于Dead状态的线程调用start()方法，会出现一个运行期(runtimeexception)的异常；处于Dead状态的线程不是活着的（notalive）。

运行原理：

java程序就是花盆里的花，花盆就是虚拟机。花盆你放在哪里（系统平台）都可以，不影响花的生长。就这么简单

JVM的工作原理：

首先，JVM就是指JAVA虚拟机

首先编译器，先将java程序源代码编译成字节码。

运行程序时：JVM会加载和解释字节码，并通过JAVA虚拟机运行

这个问题，有很多详细的资料可查

随着DEC（Digital Equipment Corp）公司Alpha处理器在 年末的发布 就意味着这个世界开始进入 位计算的时代 紧接着 全球几大主要计算机公司 如IBM Hewlett Packard（惠普） Fujitsu（富士通） Sun Microsystems 也发布了各自相应的产品进入到 位 这个市场 在 年 Fujitsu旗下的HAL Computer发布了业界第一台基于 位SPARC CPU的工作站 SPARC 此后不久 Sun发布了大众期盼已久的Ultra Ultra 工作站 其内置了Sun的 位UltraSPARC处理器 时间转换到 年 IBM发布了其第一个 位PowerPC RISC芯片 RS 在 年 IBM对RS 进行改良 使其支持SMP 这就是Power 如今看起来 对 位计算来说 其整整花了五年的时间 才在 年开始大量进入市场 在本文中 将主要涉及两个现在广泛应用的 位平台 AMD 与PowerPC 并分别使用IBM与Sun Microsystems这两个Java语言巨头提供的Java虚拟机（JVM） 通过SPECjvm 与SPECjbb 的测试 来评价 位与 位中JVM的性能 （注 SPECjvm 与SPECjbb 来自Standard Performance Evaluation Corp ）AMD 是Advanced Micro Devices（AMD）公司的 位平台 其扩展了工业标准的x 指令集架构 并设计在不降低任何性能的前提下 于 位模式中完全兼容现有的x 应用程序与 *** 作系统 在 年 月 AMD发布了Opteron 遵循AMD 架构的第一款处理器 与其同时 年 IBM发布了PowerPC 其是源自IBM Power 双核CPU的单核处理器 从此 IBM把 位PowerPC架构带到了桌面系统与低端服务器领域 另外要说明一点 PowerPC 也像Power 一样 可在不降低性能的前提下 本地执行 位指令 不久之后 在 年 月 由Apple Computer公司设计 基于PowerPC CPU的Power Mac G 电脑上市 Java背景介绍 在第一款 位处理器诞生不久 Java技术也出世了 并由此改写历史 Java是一种健壮的 通用的 面向对象的 构架中立的 可移植的 安全的 多线程的编程语言 并带有隐式内存管理功能 Java面向对象的特性在很大程度上与C++相似 但加入了更多的接口与扩展以创建更具灵活性的解决方案 与C++不同的是 Java不支持 *** 作符重载 多重继承和自动类型强制 Java通过广泛的运行时检查和内置的例外处理机制 达到健壮性的目的 编译器所生成的只是字节码指令 其是独立于任何特定平台的 这样就保证了架构中立性 可移植性是通过指定基本数据类型大小和其算术 *** 作符的行为来达到的 例如 int总表示一个有符号的 位整数 而float总表示一个 位的IEEE 浮点数 Java同时也有一系列的同步原语 其基于广泛使用的条件变量范式 自动内存垃圾回收（GC）简化了Java编程的难度 并极大地降低了bug的数目 但也使运行机制稍微复杂了点 在 年 也就是DEC公司发布第一款 位处理器的前一年 Sun Microsystems开始了一个名为 the Green Project 的计划 目的是要抢占 下一波计算 的先机 并为此提前做好准备 计划得出的最初结论是 移动数字设备与计算机的融合将会很快出现 在 年的夏天 计划小组演示了 （星 ） 一个通过动画式触摸屏控制的交互性手持娱乐设备 通过使用Oak 一种全新的编程语言 这个设备可控制很多不同的平台 而由James Gosling开发的Oak 其最主要的特点在于它是一个彻底独立于处理器的语言 在往后的几年中 这种语言被用于Internet 之后成为大众所知的Java 而 Oak 这个名字则因为版权问题从此消失了 在 年 月 Sun正式宣布Java的诞生 这是一种程序员只需编写一次 但却可在多种 *** 作系统及多种硬件平台上运行的语言 编写一次 随处运行 在 年 Sun发布了Java开发工具包（JDK ） 其后不久 个主要的 *** 作系统开发商宣布支持Java技术 当中也包括Microsoft 其以每年大约 万美元取得五年时间的Java许可协议 在 年 月 Sun发布了Java平台的第一个即时（JIT）编译器 在 年 月 JDK 面世 在随后的三周时间里 达到了 万次的下载量 到了 年初 这个数字达到两百万 在 年末 Java 平台发布了 大概半年后 也就是 年年中 Sun发布了三个版本的Java平台 J ME（Java Micro Edition） 应用于移动 无线及有限资源的环境 J SE（Java Standard Edition） 应用于桌面环境 J EE（Java Enterprise Edition） 应用于基于Java的应用服务器 此后 广泛应用的Java技术出现了一些framework 如Enterprise JavaBeans (EJB)和JavaServer Pages (JSP) Java技术的随后一次升级 是出现在 年 月的J SE 几周后 其获得了Apple公司Mac OS X的工业标准的支持 J SE 发布于 年 月份 对Java平台来说 这是一个几乎全新的产品 与J SE 相比 其多了近 %的类和接口 在这些新特性当中 还提供了广泛的XML支持 安全套接字支持（通过SSL与TLS协议） 全新的I/O API 正则表达式 日志与断言 在 年 月 是Java最近的一次发布 J SE （内部版本号 ） 代号 Tiger 现已提供公开下载 Tiger包含了从 年发布 版本以来的最重大的更新 其中包括泛型支持 基本类型的自动装箱 改进的循环 枚举类型 格式化I/O及可变参数 Java虚拟机（JVM）是一个软件规范 相关软件有责任遵守它 以运行编译为Java字节码的程序 JVM是一个抽象的计算机制 并独立于 *** 作系统 具有编译后的程序体积小 可防止执行恶意代码等特点 其没有预先假设基于任何特定的实现技术 不管是硬件还是 *** 作系统 通常我们有几个常用的JVM软件 其 位与 位版本性能有所不同 但它们都包括JIT编译器和垃圾回收功能（GC） JIT编译器从JDK 开始就是JVM的一部分了 当时Java只是用于浏览器客户端动态效果显示的一种技术 JIT编译器实现了程序执行之前Java字节码到硬件机器码的动态翻译 其背后的思想在于 相比Java源代码 字节码更小也更容易编译 但付出的代价是需要在Java字节码编译为机器码时花上一点时间 但与直接把Java源代码编译为机器码相比 时间还是少得多的 在 位与 位的JVM中 相应的JIT在把Java字节码编译为最终的机器码时 所花的时间稍微有所不同 但还能进行一些优化 另外 在IBM与Sun这两个版本的客户端与服务端程序上 总体性能也会有所不同 垃圾回收是一种自动内存管理系统 它会收回对象不再需要使用的内存 从软件工程的角度来看 垃圾回收最大的一个好处就是 程序员不用再 *** 心那些低级的内存管理细节了 同时 垃圾回收也去除了源代码中两个最大的bug 内存未释放（内存泄漏）与过早释放（指针崩溃） 内存回收在Java程序运行期间占了一个很重要的部分 因为它必须被经常执行以释放对象不再访问的Java堆 由于在 位与 位平台上 Java堆中的数据大小会有所变化 所以会因为 位与 位JVM的性能差异 导致相应垃圾回收的性能也会有所不同

位背景介绍 位计算有几个重要组成部分 第一就是 位寻址 实际上 位寻址是通过 位整数寄存器达到的（或RISC中所指的通用寄存器） 位寄存器允许 位的指针装入到单个的寄存器中 而 位的指针 才是可以寻址访问更大内存的实质所在 当 位处理器只能访问到 字节或 GB内存时 位处理器理论上却可寻址访问 字节或 × GB内存 在现代的 位系统中 可寻址的内存的实际限制通常比理论值低一点 具体依赖于特定的硬件架构和 *** 作系统 举例来说 在基于Linux的 *** 作系统中 受限于当前Linux内核数据结构的设计 可寻址的内存最多为 字节或 GB 位计算的第二个重要方面 就是 位整数运算 要提醒的是 这可不是简单地因为有了可存储更多更大整数量 更宽的 位整数寄存器而带来的必然结果 其最直接的影响就是对那些需要处理密集大数值整数运算的程序而言 可带来性能上的飞跃 第三个方面 即 位计算的特性 是 位 *** 作系统与程序的应用 相关的软件必须全面支持硬件的 位特性 包括 位寻址和运算 通常还有一些附带的好处 如 可 *** 作更多更大的文件 管理更大的磁盘等等 位计算所带来的影响 目前已在许多程序中得到了体现 数据库服务器现在可寻址更大的内存 以维持更大的缓冲池 数据缓存 或在内存中进行排序以减少相关的I/O *** 作 也能给每个用户分配更多的内存 支持更多的用户 或对更大的数据文件进行 *** 作 仿真或其他计算密集的程序也将从中受益 如 现在可以在内存中分配更大的数组了 最后 别忘了还有大量的Java程序 J EE应用服务器 现在也能充分享受到 位计算所带来的好处了 位计算的主要缺点是 与它们 位的兄弟相比 位二进制文件一般都更大 因此 最终生成的机器码体积也更大 在系统缓存与旁路转换缓存（TLB）大小不变的情况下 可能会同时降低两者的命中率 这就是说 在一定程度上性能会有所损失 性能评测 此处用于测试 位与 位JVM性能的系统 是两台 位双CPU工作站 一台是基于AMD 技术的Opteron系统 而另一台是基于PowerPC 的Apple Power Mac G 两台工作站都分别运行基于Linux的 位 *** 作系统 受测试的JVM分别来自于IBM和Sun 将使用SPEC的SPECjvm 和SPECjbb 来测试相应JVM的性能 其中SPECjvm 使用了以下项目测试客户端性能 ·_ _press 一个流行的压缩程序 ·_ _jess 一个Java版的NASA CLIPS基于规则的专家系统 ·_ _db 数据管理基准测试软件 ·_ _javac JDK Java编译器 ·_ _mpegaudio 一个MPEG 音频解码器 ·_ _mtrt 一个对图像文件进行处理的双线程程序 ·_ _jack 一个分析程序生成器 SPECjbb （Java商业基准程序）是一个用于服务端的基准测试程序 其模仿了三层体系结构 是一个通用类型的Java服务端应用程序 通过运行SPECjvm 以秒为单位记录了每个基准测试的运行时长 时间越短越好 所有SPECjvm 测试的堆大小因JVM而有所变化 从最小值 MB至最大值 MB 在SPECjbb 测试中 记录了在三种不同堆大小时的每秒执行 *** 作数 更高的值代表更高的性能 每一个测试程序都运行三次 取成绩最好的一次作为最后的结果 图 与图 显示了在AMD 平台上 Linux版本的Sun Java Standard Edition Development Kit (J SE )在SPECjvm 和SPECjbb 中 位与 位的性能测试结果 在SPECjvm 测试中 只有三项 _ _press _ _mpegaudio _ _jack 在 位版本的JVM上比 位表现出更佳的性能 在SPECjbb 中 位版本的性能只在有足够堆大小的情况下 才表现出更高的性能 其中在堆大小为 MB时 因为某些活动数据在 位JVM版本中体积更大 导致垃圾回收动作更频繁 从而降低了程序性能

图 图 图 与图 显示了在AMD 平台上 Linux版本的IBM Developer Kit for Linux Java Technology Edition Version GA在SPECjvm 和SPECjbb 中 位与 位的性能测试结果 其中 基准测试程序中有三项 _ _db _ _javac _ _jack 在 位环境下表现出了更佳的性能 另外 在SPECjbb 测试中 当面对三个不同大小的测试堆时 位IBM版本的JVM都没有表现出比 位版本更好的性能 图 图 图 与图 显示了在PowerPC 平台上 IBM Developer Kit for Linux Java Technology Edition Version GA在SPECjvm 和SPECjbb 中 位与 位的性能测试结果 此处 在所有SPECjvm 和SPECjbb 的测试中 位JVM的性能都不及 位平台 图 图 结论 基于运行Linux *** 作系统的PowerPC 平台的测试结果 表明如果在此平台上使用IBM的JVM 那么 那些不需要 位特性的程序 还是让它们运行在 位JVM中吧 因为在此平台的所有测试结果中 位JVM的性能都比 位平台低 而基于运行Linux *** 作系统的AMD 平台的测试结果 表明不管是Sun还是IBM的JVM 位与 位的性能都在伯仲之间 要注意的是 性能的差异是依赖于具体的应用程序与JVM的 如果需要最佳性能 就必须在某个特定的执行环境中测试某个特定的程序 以评价转换到 位所带来的潜在性能提升 有几件事情需重点注意 第一 尽管SPECjvm 与SPECjbb 都是工业标准的基准测试程序 但它们的测试范围有限 因此 就测试结果而言 只对一部分的Java程序正确 而不是所有 第二 随着 位计算越来越被人们接受 我们期待 位程序会有所改进 包括 位JVM 也许其在将来会大幅提高性能 第三 此处只组合测试了几种特定的硬件平台 *** 作系统与JVM 因此 如果要进一步地说明问题 恐怕只有在 位Windows XP/ 及 位Mac OS X上的进行JVM基准测试了 lishixinzhi/Article/program/Java/hx/201311/26587

首先这里澄清两个概念：JVM实例和JVM执行引擎实例，JVM实例对应了一个独立运行的Java程序，而JVM执行引擎实例则对应了属于用户运行程序的线程；也就是JVM实例是进程级别，而执行引擎是线程级别的。JVM是什么？—JVM的生命周期JVM实例的诞生：当启动一个Java程序时，一个JVM实例就产生了，任何一个拥有publicstaticvoidmain(String[]args)函数的class都可以作为JVM实例运行的起点，既然如此，那么JVM如何知道是运行classA的main而不是运行classB的main呢？这就需要显式的告诉JVM类名，也就是我们平时运行Java程序命令的由来，如JavaclassAhelloworld,这里Java是告诉os运行SunJava2SDK的Java虚拟机，而classA则指出了运行JVM所需要的类名。JVM实例的运行：main（）作为该程序初始线程的起点，任何其他线程均由该线程启动。JVM内部有两种线程：守护线程和非守护线程，main（）属于非守护线程，守护线程通常由JVM自己使用，Java程序也可以标明自己创建的线程是守护线程。JVM实例的消亡：当程序中的所有非守护线程都终止时，JVM才退出；若安全管理器允许，程序也可以使用Runtime类或者Systemexit()来退出。JVM是什么？—JVM的体系结构粗略分来，JVM的内部体系结构分为三部分，分别是：类装载器（ClassLoader）子系统，运行时数据区，和执行引擎。下面将先介绍类装载器，然后是执行引擎，最后是运行时数据区1、类装载器，顾名思义，就是用来装载class文件的。JVM的两种类装载器包括：启动类装载器和用户自定义类装载器，启动类装载器是JVM实现的一部分，用户自定义类装载器则是Java程序的一部分，必须是ClassLoader类的子类。（下面所述情况是针对SunJDK12）动类装载器：只在系统类(JavaAPI的类文件)的安装路径查找要装入的类用户自定义类装载器：系统类装载器：在JVM启动时创建，用来在CLASSPATH目录下查找要装入的类其他用户自定义类装载器：这里有必要先说一下ClassLoader类的几个方法，了解它们对于了解自定义类装载器如何装载class文件至关重要。protectedfinalClassdefineClass(Stringname,bytedata[],intoffset,intlength) protectedfinalClassdefineClass(Stringname,bytedata[],intoffset,intlength,ProtectionDomainprotectionDomain);protectedfinalClassfindSystemClass(Stringname) protectedfinalvoidresolveClass(Classc) defineClass用来将二进制class文件（新类型）导入到方法区,也就是这里指的类是用户自定义的类（也就是负责装载类）findSystemClass通过类型的全限定名，先通过系统类装载器或者启动类装载器来装载，并返回Class对象。ResolveClass:让类装载器进行连接动作（包括验证，分配内存初始化，将类型中的符号引用解析为直接引用），这里涉及到Java命名空间的问题，JVM保证被一个类装载器装载的类所引用的所有类都被这个类装载器装载，同一个类装载器装载的类之间可以相互访问，但是不同类装载器装载的类看不见对方，从而实现了有效的屏蔽。2、执行引擎：它或者在执行字节码，或者执行本地方法要说执行引擎，就不得不的指令集，每一条指令包含一个单字节的 *** 作码，后面跟0个或者多个 *** 作数。（一）指令集以栈为设计中心，而非以寄存器为中心这种指令集设计如何满足Java体系的要求：平台无关性：以栈为中心使得在只有很少register的机器上实现Java更便利compiler一般采用stack向连接优化器传递编译的中间结果，若指令集以stack为基础，则有利于运行时进行的优化工作与执行即时编译或者自适应优化的执行引擎结合，通俗的说就是使编译和运行用的数据结构统一，更有利于优化的开展。网络移动性：class文件的紧凑性。安全性：指令集中绝大部分 *** 作码都指明了 *** 作的类型。（在装载的时候使用数据流分析期进行一次性验证，而非在执行每条指令的时候进行验证，有利于提高执行速度）。（二）执行技术主要的执行技术有:解释，即时编译，自适应优化、芯片级直接执行其中解释属于第一代JVM，即时编译JIT属于第二代JVM，自适应优化（目前Sun的HotspotJVM采用这种技术）则吸取第一代JVM和第二代JVM的经验，采用两者结合的方式自适应优化：开始对所有的代码都采取解释执行的方式，并监视代码执行情况，然后对那些经常调用的方法启动一个后台线程，将其编译为本地代码，并进行仔细优化。若方法不再频繁使用，则取消编译过的代码，仍对其进行解释执行。3、运行时数据区：主要包括：方法区，堆，Java栈，PC寄存器，本地方法栈（1）方法区和堆由所有线程共享堆：存放所有程序在运行时创建的对象方法区：当JVM的类装载器加载class文件，并进行解析，把解析的类型信息放入方法区。（2）Java栈和PC寄存器由线程独享，在新线程创建时间里（3）本地方法栈：存储本地方法调用的状态上边总体介绍了运行时数据区的主要内容，下边进行详细介绍，要介绍数据区，就不得不说明JVM中的数据类型。JVM中的数据类型：JVM中基本的数据单元是word,而word的长度由JVM具体的实现者来决定数据类型包括基本类型和引用类型，（1）基本类型包括：数值类型(包括除boolean外的所有的Java基本数据类型)，boolean（在JVM中使用int来表示，0表示false，其他int值均表示true）和returnAddress（JVM的内部类型，用来实现finally子句）。（2）引用类型包括：数组类型，类类型，接口类型前边讲述了JVM中数据的表示，下面让我们输入到JVM的数据区首先来看方法区：上边已经提到，方法区主要用来存储JVM从class文件中提取的类型信息，那么类型信息是如何存储的呢？众所周知，Java使用的是大端序（bigendian:即低字节的数据存储在高位内存上，如对于1234，12是高位数据，34为低位数据，则Java中的存储格式应该为12存在内存的低地址，34存在内存的高地址，x86中的存储格式与之相反）来存储数据，这实际上是在class文件中数据的存储格式，但是当数据倒入到方法区中时，JVM可以以任何方式来存储它。类型信息：包括class的全限定名，class的直接父类，类类型还是接口类型，类的修饰符（public,等），所有直接父接口的列表，Class对象提供了访问这些信息的窗口（可通过ClassforName(“”)或instancegetClass()获得），下面是Class的方法，相信大家看了会恍然大悟，（原来如此J）getName(),getSuperClass(),isInterface(),getInterfaces(),getClassLoader();static变量作为类型信息的一部分保存指向ClassLoader类的引用：在动态连接时装载该类中引用的其他类指向Class类的引用：必然的，上边已述该类型的常量池：包括直接常量（String，integer和floatpoint常量）以及对其他类型、字段和方法的符号引用（注意：这里的常量池并不是普通意义上的存储常量的地方，这些符号引用可能是我们在编程中所接触到的变量），由于这些符号引用，使得常量池成为Java程序动态连接中至关重要的部分字段信息：普通意义上的类型中声明的字段方法信息：类型中各个方法的信息编译期常量：指用final声明或者用编译时已知的值初始化的类变量class将所有的常量复制至其常量池或者其字节码流中。方法表：一个数组，包括所有它的实例可能调用的实例方法的直接引用（包括从父类中继承来的）除此之外，若某个类不是抽象和本地的，还要保存方法的字节码， *** 作数栈和该方法的栈帧，异常表。举例：classLava{ privateintspeed=5; voidflow(){} classVolcano{ publicstaticvoidmain(String[]args){ Lavalava=newLava(); lavaflow(); } } 运行命令JavaVolcano;（1）JVM找到Volcanoclass倒入，并提取相应的类型信息到方法区。通过执行方法区中的字节码，JVM执行main（）方法，（执行时会一直保存指向Vocano类的常量池的指针）（2）Main（）中第一条指令告诉JVM需为列在常量池第一项的类分配内存（此处再次说明了常量池并非只存储常量信息），然后JVM找到常量池的第一项，发现是对Lava类的符号引用，则检查方法区，看Lava类是否装载，结果是还未装载，则查找“Lavaclass”,将类型信息写入方法区，并将方法区Lava类信息的指针来替换Volcano原常量池中的符号引用，即用直接引用来替换符号引用。（3）JVM看到new关键字，准备为Lava分配内存，根据Volcano的常量池的第一项找到Lava在方法区的位置，并分析需要多少对空间，确定后，在堆上分配空间，并将speed变量初始为0，并将lava对象的引用压到栈中（4）调用lava的flow（）方法好了，大致了解了方法区的内容后，让我们来看看堆Java对象的堆实现：Java对象主要由实例变量（包括自己所属的类和其父类声明的）以及指向方法区中类数据的指针，指向方法表的指针，对象锁（非必需），等待集合（非必需），GC相关的数据（非必需）（主要视GC算法而定，如对于标记并清除算法，需要标记对象是否被引用，以及是否已调用finalize（）方法）。那么为什么Java对象中要有指向类数据的指针呢？我们从几个方面来考虑首先：当程序中将一个对象引用转为另一个类型时，如何检查转换是否允许？需用到类数据其次：动态绑定时，并不是需要引用类型，而是需要运行时类型，这里的迷惑是：为什么类数据中保存的是实际类型，而非引用类型？这个问题先留下来，我想在后续的读书笔记中应该能明白指向方法表的指针：这里和C++的VTBL是类似的，有利于提高方法调用的效率对象锁：用来实现多个线程对共享数据的互斥访问等待集合：用来让多个线程为完成共同目标而协调功过。（注意Object类中的wait(),notify(),notifyAll()方法）。Java数组的堆实现：数组也拥有一个和他们的类相关联的Class实例，具有相同dimension和type的数组是同一个类的实例。数组类名的表示：如[[LJava/lang/Object表示Object[][]，[I表示int[]，[[[B表示byte[][][]至此，堆已大致介绍完毕，下面来介绍程序计数器和Java栈程序计数器：为每个线程独有，在线程启动时创建，若thread执行Java方法，则PC保存下一条执行指令的地址。若thread执行native方法，则Pc的值为undefinedJava栈：Java栈以帧为单位保存线程的运行状态，Java栈只有两种 *** 作，帧的压栈和出栈。每个帧代表一个方法，Java方法有两种返回方式，return和抛出异常，两种方式都会导致该方法对应的帧出栈和释放内存。帧的组成：局部变量区（包括方法参数和局部变量，对于instance方法，还要首先保存this类型，其中方法参数按照声明顺序严格放置，局部变量可以任意放置）， *** 作数栈，帧数据区（用来帮助支持常量池的解析，正常方法返回和异常处理）。本地方法栈：依赖于本地方法的实现，如某个JVM实现的本地方法借口使用C连接模型，则本地方法栈就是C栈，可以说某线程在调用本地方法时，就进入了一个不受JVM限制的领域，也就是JVM可以利用本地方法来动态扩展本身。相信大家都明白JVM是什么了吧。原文链接： >

虚拟机：指以软件的方式模拟具有完整硬件，VM概念

虚拟机：指以软件的方式模拟具有完整硬件系统功能、运行在一个完全隔离环境中的完整计算机系统 ，是物理机的软件实现。常用的虚拟机有VMWare，Visual Box，Java Virtual Machine（Java虚拟机，简称JVM）。

Java语言的一个非常重要的特点就是与平台的无关性。而使用Java虚拟机是实现这一特点的关键。一般的高级语言如果要在不同的平台上运行，至少需要编译成不同的目标代码。而引入Java语言虚拟机后，Java语言在不同平台上运行时不需要重新编译。Java语言使用Java虚拟机屏蔽了与具体平台相关的信息，使得Java语言编译程序只需生成在Java虚拟机上运行的目标代码(字节码)，就可以在多种平台上不加修改地运行。Java虚拟机在执行字节码时，把字节码解释成具体平台上的机器指令执行。这就是Java的能够"一次编译，到处运行"的原因。

Java虚拟机阵营：Sun HotSpot VM、BEA JRockit VM、IBM J9 VM、Azul VM、Apache Harmony、Google Dalvik VM、Microsoft JVM…

启动流程





JVM由三个主要的子系统构成：

1类加载器子系统

2运行时数据区（内存）

3执行引擎





JVM原理

JVM是java的核心和基础，在java编译器和os平台之间的虚拟处理器。它是一种基于下层的 *** 作系统和硬件平台并利用软件方法来实现的抽象的计算机，可以在上面执行java的字节码程序。

java编译器只需面向JVM，生成JVM能理解的代码或字节码文件。Java源文件经编译器，编译成字节码程序，通过JVM将每一条指令翻译成不同平台机器码，通过特定平台运行。

JVM执行程序的过程 :

I加载class文件

II管理并分配内存

III执行垃圾收集

JRE(java运行时环境)包含JVM的java程序的运行环境

JVM是Java程序运行的容器,但是他同时也是 *** 作系统的一个进程,因此他也有他自己的运行的生命周期,也有自己的代码和数据空间。

JVM在整个jdk中处于最底层,负责与 *** 作系统的交互,用来屏蔽 *** 作系统环境,提供一个完整的Java运行环境,因此也叫虚拟计算机 *** 作系统装入JVM是通过jdk中Javaexe来完成,通过下面4步来完成JVM环境。

1创建JVM装载环境和配置

2装载JVMdll

3初始化JVMdll并挂接到JNIENV(JNI调用接口)实例

4调用JNIEnv实例装载并处理class类。

寄存器

所有的CPU均包含用于保存系统状态和处理器所需信息的寄存器组。如果虚拟机定义较多的寄存器，便可以从中得到更多的信息而不必对栈或内存进行访问，这有利于提高运行速度。然而，如果虚拟机中的寄存器比实际CPU的寄存器多，在实现虚拟机时就会占用处理器大量的时间来用常规存储器模拟寄存器，这反而会降低虚拟机的效率。针对这种情况，JVM只设置了4个最为常用的寄存器。它们是:

pc程序计数器

optop *** 作数栈顶指针

frame当前执行环境指针

vars指向当前执行环境中第一个局部变量的指针

所有寄存器均为32位。pc用于记录程序的执行。optop,frame和vars用于记录指向Java栈区的指针。寄存器

栈结构

作为基于栈结构的计算机，Java栈是JVM存储信息的主要方法。当JVM得到一个Java字节码应用程序后，便为该代码中一个类的每一个方法创建一个栈框架，以保存该方法的状态信息。每个栈框架包括以下三类信息:

局部变量

执行环境

*** 作数栈

局部变量用于存储一个类的方法中所用到的局部变量。vars寄存器指向该变量表中的第一个局部变量。

执行环境用于保存解释器对Java字节码进行解释过程中所需的信息。它们是:上次调用的方法、局部变量指针和 *** 作数栈的栈顶和栈底指针。执行环境是一个执行一个方法的控制中心。例如:如果解释器要执行iadd(整数加法)，首先要从frame寄存器中找到当前执行环境，而后便从执行环境中找到 *** 作数栈，从栈顶d出两个整数进行加法运算，最后将结果压入栈顶。

*** 作数栈用于存储运算所需 *** 作数及运算的结果。

运行数据

JVM定义了若干个程序执行期间使用的数据区域。这个区域里的一些数据在JVM启动的时候创建，在JVM退出的时候销毁。而其他的数据依赖于每一个线程，在线程创建时创建，在线程退出时销毁。分别有程序计数器，堆，栈，方法区，运行时常量池。

运行过程

上面对虚拟机的各个部分进行了比较详细的说明，下面通过一个具体的例子来分析它的运行过程。

虚拟机通过调用某个指定类的方法main启动，传递给main一个字符串数组参数，使指定的类被装载，同时链接该类所使用的其它的类型，并且初始化它们。新建一java源文件并取名HelloAppjava，内容如下:

class HelloApp {

public static void main(String[] args) {

Systemoutprintln("Hello World!");

for (int i = 0; i < argslength; i++ ) {

Systemoutprintln(args);

}

}

}

在命令模式下输入:javac HelloAppjava 进行编译，这时同目录下会产生一个编译后的文件:HelloAppclass

然后在命令行模式下键入:java HelloApp run virtual machine

将通过调用HelloApp的方法main来启动java虚拟机，传递给main一个包含三个字符串"run"、"virtual"、"machine"的数组。我们略述虚拟机在执行HelloApp时可能采取的步骤。





JVM虚拟机运行过程

开始试图执行类HelloApp的main方法，发现该类并没有被装载，也就是说虚拟机当前不包含该类的二进制代表，于是虚拟机使用ClassLoader试图寻找这样的二进制代表。如果这个进程失败，则抛出一个异常。类被装载后同时在main方法被调用之前，必须对类HelloApp与其它类型进行链接然后初始化。链接包含三个阶段:检验，准备和解析。检验检查被装载的主类的符号和语义，准备则创建类或接口的静态域以及把这些域初始化为标准的默认值，解析负责检查主类对其它类或接口的符号引用，在这一步它是可选的。类的初始化是对类中声明的静态初始化函数和静态域的初始化构造方法的执行。一个类在初始化之前它的父类必须被初始化。

以上就是关于深入Java底层：内存屏障与JVM并发详解全部的内容，包括:深入Java底层：内存屏障与JVM并发详解、Java线程Thread.class源码中未找到线程状态切换的地方，请教各位大神，threadStatus切换源代码在哪里找、Java的运行原理及JVM虚拟机是怎么工作的等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！