【《深入理解Java虚拟机》】JVM的秘密—Part2

 2019-12-22 11:10  阅读(896)
文章分类:JVM

【《深入理解Java虚拟机》Part2】

3.5【虚拟机字节码执行引擎】

【3.6 方法调用】

【分派】

【3.6 基于栈的字节码解释执行引擎】

【3.7】 类加载及执行子系统的案例与实战

【4】高效并发

【4.1】Java内存模型与线程

【4.2 线程安全与锁优化】

2019120001597\_1.png

双亲委派模型要求除了顶层的启动类加载器外,其它类加载器都应当有自己的父类加载器。使用Compositon关系来复用父加载器【双亲委派模型的工作过程】如果一个类加载器收到了类加载的请求,它首先不会自己去尝试加载这个类,而是把这个请求委派给父类加载器去完成,每一个层次的类加载器都是如此,因此所有的加载请求最终都应该传送到顶层的启动类加载器中,只有当父类加载器反馈自己无法完成这个加载请求(它的搜索范围中没有找到所需的类)时,子加载器才会尝试自己去加载。

2019120001597\_2.png

2019120001597\_3.png

2019120001597\_4.png2019120001597\_5.png

3.5【虚拟机字节码执行引擎】

所有Java虚拟机的执行引擎都是一致的:输入的是字节码文件,处理过程是字节码解析的等效过程,输出的是执行结果。

栈帧(Stack Frame)是用于支持虚拟机进行方法调用和方法执行的数据结构,是虚拟机运行时数据区中的虚拟机栈(Virtual Machine Stack)的栈元素。存储了方法的局部变量表、操作数栈、动态连接和方法返回地址等信息。在编译代码的时候,就已经确定并写入到方法表的Code属性之中。

2019120001597\_6.png 一个Slot可以存放一个32位以内的数据类型,Java中占用32位以内的数据类型有8种类型:boolean、byte、char、short、int、float、reference和returnAddress。64位的数据类型:long and double 。reference类型可能是32位 or 64位。

【类变量2次赋值】1:准备阶段,赋予系统初始值。2.初始化阶段,赋予程序员定义的初始值。

2019120001597\_7.png

  • 局部变量表:一组变量值存储空间,用于存放方法参数和方法内部定义的局部变量,其容量以Slot为最小单位。
  • 操作数栈:2019120001597\_8.png
  • 动态连接:2019120001597\_9.png
  • 方法返回地址:2019120001597\_10.png
  • 附加信息:虚拟机规范允许具体的虚拟机实现增加一些规范里没有描述的消息到栈帧之中,例如与调试相关的信息,这部分信息完全取决于具体的虚拟机实现。在实际开发中,一般会把动态连接、方法返回地址与其他附加信息全部归位一类,称为栈帧信息。

【3.6 方法调用】

方法调用阶段唯一的任务就是:确定被调用方法的版本(即调用哪一个方法),暂时不涉及方法内部的具体运行过程。

1.解析:前提是方法在程序真正运行之前就有一个可确定的调用版本,并且这个方法的调用版本在运行期是不可改变的。 调用目标在程序代码写好、编译器进行编译时就必须确定下来。

2019120001597\_11.png 与之相对应,在Java虚拟机里面提供了4条方法调用字节码指令,分别是:

1.invokestatic:调用静态方法。

2.invokespecial:调用实例构造器方法、私有方法金额父类方法

3.invokevirtual:调用所有的虚方法

4.invokeinterface:调用接口方法,会在运行时再确定一个实现此接口的对象。

2019120001597\_12.png2019120001597\_13.png

【分派】

1.静态分派:典型就是重载Overload,编译阶段完成。

2019120001597\_14.png

Human man = new Man() Human为静态类型或外观类型,new Man() 则为实际类型。

区别:静态类型的变化仅仅在使用时发生,变量本身的静态类型不会被改变,并且最终的静态类型是在编译期可知的。实际类型变化的结果在运行期才能确定。

在编译阶段,Java编译期就根据参数的静态类型决定使用哪个重载版本,重载时是通过参数的静态类型而不是实际类型确定。

2019120001597\_15.png

char自动转型:char—>int—–>long—->float—->double,但不会匹配到byte和short类型的重载,因为不安全。

java.lang.Serializable 是 java.lang.Character 类实现的一个接口,char可以转型成int,但是Character是绝对不会转型为Integer的,它只能安全地转型为它实现的接口或父类。java.lang.Comparable和java.lang.Serializable优先级一样。

2.动态分派:典型是重写Override

2019120001597\_16.png

2019120001597\_17.png

2019120001597\_18.png

java语言使用一门静态多分派、动态单分派的语言

2019120001597\_19.png

2019120001597\_20.png

【3.6 基于栈的字节码解释执行引擎】

2019120001597\_21.png

Java语言中,Javac编译器完成了程序代码经过词法分析、语法分析到抽象语法树,再遍历语法树生成线性的字节码指令流的过程

【3.6.1】基于栈的指令集与基于寄存器的指令集

2019120001597\_22.png

区别:

栈的指令集:可移植性强、执行慢一些(指令集代码紧凑但相同功能所需指令数量多,频繁的访问内存)。

寄存器:执行速度快、可移植性差。

【基于栈的解释器执行过程】

2019120001597\_23.png

【3.7】 类加载及执行子系统的案例与实战

2019120001597\_24.png

2019120001597\_25.png

Tomcat 6.0x把/common、/server、/shared默认合并到 /lib目录 ,权限相当于 /common 目录类库的作用。

【OSGI】模块(Bundle)都以JAR格式进行封装,并且内部存储的都是Java package 和Class。一个Bundle里只有被Export过的package才可能被外界访问,其他的package 和 Class都会被隐藏起来。Import-Package 和 Export-Package

依赖关系:上层模块依赖底层模块——->平级模块之间的依赖 类加载器之间只有规则,没有固定的委派关系。

PS:如果出现了Bundle A依赖Bundle B的package B,而Bundle B又依赖了Bundle A的package A,死锁怎么解决?

【动态代理】动态代理中的“动态”是针对使用Java代码实际编写了代理类的“静态”代理而言的,优势:不在于省去了编写代理类工作量,是实现了可以在原始类和接口还未知的时候就确定代理类的代理行为,当代理类和原始类脱离直接联系后,可灵活重用于不同的应用场景之中。

2019120001597\_26.png

实战:见书 246页

【4】高效并发

【4.1】Java内存模型与线程

2019120001597\_27.png

基于高速缓存的存储交互很好地解决了处理器与内存的速度矛盾,但是引入新的问题:缓存一致性(Cache Coherence)、乱序执行优化(Out-of-Order Execution)优化

**【Java内存模型】****JMM(Java Memory Model)来屏蔽掉各种硬件和操作系统的内存访问差异,以实现让Java程序员在各种平台下都能达到一致的并发效果。目标:定义程序中各个变量的访问规则,即在虚拟机中将变量存储到内存和从内存中取出变量这样的底层细节。变量:实例字段、静态字段和构成数组对象的元素但不包括线程私有的局部变量与方法参数。**

2019120001597\_28.png

2019120001597\_29.png

2019120001597\_30.png

2019120001597\_31.png

【内存间交互操作】

2019120001597\_32.png

2019120001597\_33.png

2019120001597\_34.png

2019120001597\_35.png

==================================================================================================

2019120001597\_36.png

2019120001597\_37.png

==================================================================================================

2019120001597\_38.png2019120001597\_39.png

2019120001597\_40.png

2019120001597\_41.png

=================================================================================================

2019120001597\_42.png

==================================================================================================

【原子性、可见性 以及有序】

2019120001597\_43.png

2019120001597\_44.png

2019120001597\_45.png

2019120001597\_46.png

2019120001597\_47.png

2019120001597\_48.png

==================================================================================================2019120001597\_49.png 2019120001597\_50.png

2019120001597\_51.png

2019120001597\_52.png

2019120001597\_53.png

2019120001597\_54.png

==================================================================================================

【线程的实现 NO Java线程的实现】

2019120001597\_55.png 2019120001597\_56.png

2019120001597\_57.png

2019120001597\_58.png

2019120001597\_59.png

2019120001597\_60.png

==================================================================================================

【Java线程】-XX:+UseLWPSynchronization(默认值)和 -XX:+UseBoundThreads来明确执行虚拟机使用的是哪种线程模型。

线程调度是指系统为线程分配处理器使用权的过程,主要调用方式有2种,分别是:

协同式(Cooperative Threads-Scheduling)线程调度:线程的执行时间由线程本身控制,实现简单,而且由于线程要把自己的事情干完后才会进行线程切换, 切换线程操作对于自己是可知的。劣势:时间不可控制,如果一个线程编写有问题,一直不告诉系统进行线程切换,那么程序就会一直阻塞在那里。

抢占式(Preemptive Threads-Scheduling)线程调度:由系统分配执行时间,切换不由本身决定。

2019120001597\_61.png

2019120001597\_62.png

2019120001597\_63.png

2019120001597\_64.png

==================================================================================================

【4.2 线程安全与锁优化】

**线程安全:**当多个线程访问一个对象时,如果不用考虑这些线程在运行时环境下的调度和交替执行,也不需要进行额外的同步,或者在调用方进行任何其他的协调操作,调用这个对象的行为(单次调用)都可以获得正确的结果。

Java语言中各种操作共享的数据分为5类:不可变、绝对线程安全、相对线程安全、线程兼容和线程对立。

  • 不可变:2019120001597\_65.png2019120001597\_66.png
  • 绝对线程安全:2019120001597\_67.png
  • 相对线程安全:2019120001597\_68.png
  • 线程兼容:2019120001597\_69.png
  • 线程对立:2019120001597\_70.png

==================================================================================================

【线程安全的实现方法】

  1. 互斥同步:2019120001597\_71.png2019120001597\_72.png2019120001597\_73.png2019120001597\_74.png2019120001597\_75.png
  2. 非阻塞同步:互斥同步最主要的问题就是进行线程阻塞和唤醒所带来的性能问题,因此这种同步也被成为阻塞同步。2019120001597\_76.png

我们需要操作和冲突检测这两个步骤 ,考硬件来完成这件事情,硬件保证一个从语义上看起来需要多次操作的行为只通过一条处理器指令就能完成,这类指令常用的有:

测试并设置(Test-and-Set)

获取并增加(Fetch-and-Increment)

交换(Swap)

比较并交换(Compare-and-Swap CAS)

加载链接/条件储存(Load-Linked / Store-Conditional LL/SC)

2019120001597\_77.png

2019120001597\_78.png

  1. 无同步方案:要保证线程安全,并不是一定就要进行同步,两者没有因果关系。同步只是保障数据争用时的正确性手段,如果一个方法本来就不涉及共享数据,那它自然就无须任何同步措施去保证正确性,因此会有一些代码天生就是线程安全的。
  2. 可重入代码:也叫纯代码,

2019120001597\_79.png

  1. 线程本地存储:

2019120001597\_80.png

2019120001597\_81.png

==================================================================================================

【锁优化】

  1. 自旋锁 与 自适应自旋: 自旋锁:两个或以上的线程同时并行执行,就可以让后面请求锁的哪个线程“稍等一会儿”,但不放弃处理器的执行时间,看看持有锁的线程是否很快就会释放锁。为了让线程等待,我们只须让线程执行一个忙循环(自旋)。 -XX:+UseSpinning 参数来开启自旋锁,默认是开启的,自旋次数的默认是10次,由-XX:PreBlocckSpin 来更改。 自适应自旋:自适应意味着自旋的时间不再固定了,而是由前一次在同一个锁上的自旋时间及锁的拥有者的状态来决定
  2. 锁消除:**是指虚拟机即时编译器在运行时,对一些代码上要求同步,但是被检测到不可能存在共享数据竞争的锁进行消除。**主要判定依据:逃逸分析的数据支持,如果判断到一段代码中,在堆上的所有数据都不会逃逸出去被其他线程访问到,那就可以把它们当做栈上数据对待,认为它们是线程私有的,同步加锁自然就无须进行。
  3. 锁粗化:写代码时总是推荐将同步块的作用范围限制得尽量小——只在共享数据的实际作用域中才进行同步,这样是为了使得需要同步的操作数量尽可能变小,如果存在锁竞争,那等待锁的线程也能尽快地拿到锁。2019120001597\_82.png
  4. 轻量级锁:并是不用来代替重量级锁的,它的本意是在没有多线程竞争的前提下,减少系统的重量级锁使用操作系统互斥量产生的性能消耗。2019120001597\_83.png2019120001597\_84.png 2019120001597\_85.png2019120001597\_86.png2019120001597\_87.png2019120001597\_88.png
  5. 偏向锁:2019120001597\_89.png2019120001597\_90.png
点赞(1)
版权归原创作者所有,任何形式转载请联系作者; Java 技术驿站 >> 【《深入理解Java虚拟机》】JVM的秘密—Part2

相关推荐