深入java虚拟机第二版阅读笔记(不断整理中)

问题使人深思

   
1 class文件是如何被调入内存执行的? 加载原理？
  深入探讨 Java 类加载器：http://www.ibm.com/developerworks/cn/java/j-lo-classloader/
  深入Java虚拟机JVM类加载初始化学习笔记 http://developer.51cto.com/art/201103/249613.htm
2 类的静态方法和静态变量的初始化是按照什么步骤进行的？
 
3 对象的垃圾收集（GC）是如何以及在什么时候发生的? java内存如何管理的？

4 问：垃圾回收器的基本原理是什么?垃圾回收器可以马上回收内存吗?有什么办法主动通知虚拟机进行垃圾回收?
答：对于GC来说,当程序员创建对象时,GC就开始监控这个对象的地址、大小以及使用情况.
   通常,GC采用有向图的方式记录和管理堆(heap)中的所有对象.通过这种方式确定哪些对象是"可达的",哪些对象
   是"不可达的".当GC确定一些对象为"不可达"时,GC就有责任回收这些内存空间.
   可以. 程序员可以手动执行System.gc(),通知GC运行,但是Java语言规范并不保证GC一定会执行.
5 JVM(JRE)设计哲学？
  (1)类或模块加载原理，并可以观察 如：JProfiler工具查看  (java虚拟机)
  (2)虚拟机内存管理机制，并可以观察，并与C,C++进行比较（内存创建，内存释放GC，内存管理等）
6 类或模块加载原理？当自己编写的WebApp中的jar文件与tomcat中的jar文件加载顺序如何？
  当同一个文件不同版本的jar文件，tomcat如何加载呢？
7 虚拟机内存管理机制？
  如何使用内存？内存创建？使用？如何释放？在内存释放方面与C或C++相比有什么不同？

本书作者曾因本书荣获专业技术杂志《Java Report》评选的优秀作者奖。细心的读者可以从网上找到许多对本书第1版的赞誉。
作者以易于理解的方式深入揭示了Java虚拟机的内部工作原理，深入理解这些内容，将对读者更快速地编写更高效的程序大有裨益！
本书共分20章，
第1-4章介绍Java体系结构，包括Java程序设计语言、Java 应用程序接口、Java class文件格式、Java class加载原理、Java虚拟机部分；
第5-9章介绍JVM体系结构（第五章总说JVM体系结构，后续四章从不同角度分说）
第5-20章深入描述了Java技术的内部细节，包括垃圾收集、Java安全模型、Java的连接模型和动态扩展机制、class文件、运算及流程控制等等，10章到20章：关于java虚拟机指令集的教程  执行引擎的抽象规范是根据指令集来定义的
其中等6章和附录A-C完全可以作为class文件和指令含集的参考手册。
本书还附带光盘，光盘中包含用以辅助说明正文内容的交互式例示apple及示例源代码。
《虚拟机》-第一章、第五章
　　1，最有价值章节：5，6, 7，8，9，20，值得反复精读。
　　2，更深一步的话，3，6，17，18是值得阅读的

　　3，余下关于指令的，若没实操项目，不必精读。

第一章 Java体系结构介绍（研习次:1 掌握层次：领会）

   1.1 为什么使用Java
   1.2 网络带来的挑战和机遇
   1.3 体系结构
        体系结构：
      Java程序设计语言The Java Programming Language： java语言规范(Java-Language-Specification-3rd-Edition.chm)
          Java 应用程序接口（API）(类库:The Java API)： （Think in java/ Core java/ JDK API help）
          Java class文件格式(The Java Class File): Java class文件 《深入浅出Java虚拟机》第六章 Java class文件
          Java class加载原理：The Class Loader Architecture（ClassLoader）
      Java虚拟机（The Java Virtual Machine（JVM）,,GC）：java虚拟机《深入浅出Java虚拟机》
     1.3.1 Java虚拟机
          主要任务是 装载class文件并且执行其中的字节码（byteCode）, Java虚拟机包含一个类装载器（class loader）,它
          可以从程序和API中装载class文件。Java API中只有程序执行时需要的那些类才会被装载。字节码有执行引擎来执行。
          Java虚拟机中，执行引擎不同实现：
          （1） 在有软件实现的虚拟机中，最简单的执行引擎就是一次性解释字节码。
          （2） 另一种执行引擎更快，但是也更消耗内存，叫做“即时编译器”（just-in-time compiler）。在这种情况下，第
                一次被执行的字节码会被编译成本地机器代码。编译出来的本地机器代码会被缓存，当方法以后被调用的时候可以
                重用。
          （3） 执行引擎是自动适应优化器。虚拟机开始的时候解释字节码，但是会检视运行中程序的活动，并且记录下使用最频
                繁的代码段。程序运行的时候，虚拟机只把那些活动最频繁的代码编译成本地代码，其他的代码由于使用的并不很
                频繁，继续保留为字节码--由虚拟机继续解释他们。 一个自适应的优化器可以使得Java虚拟机在80%-90%的时间里
               执行被优化过的本地代码，而只需要编译10%-20%对性能有影响的代码。
          （4）虚拟机由硬件芯片构成，它用本地方法执行Java字节码，这种执行引擎实际上是内嵌在芯片里的。
           Java中有两种方法：Java方法 和 本地方法（JNI ,其他语言C,C++,汇编等与具体平台有关）
     1.3.2 类装载器的体系结构
           类装载器：
            （1）*启动（bootstrap）类装载器 （启动类装载器也被称为原始类装载器，系统类装载器或者默认类装载器）
                  它用来加载 Java 的核心库(jdk1.6.0_11\jre\lib\rt.jar)，是用原生代码来实现的，并不继承自
                  java.lang.ClassLoader。
                *扩展类加载器（extensions class loader）：它用来加载 Java 的扩展库。Java 虚拟机的实现会提供一个扩展库目录
                  (jdk1.6.0_11\jre\lib\ext)。该类加载器在此目录里面查找并加载 Java 类。
                *系统类加载器（system class loader）：它根据 Java 应用的类路径（CLASSPATH）来加载 Java 类。一般来说，                 Java 应用的类都是由它来完成加载的。可以通过 ClassLoader.getSystemClassLoader() 来获取它。
            （2）用户自定义的类装载器:系统提供的类加载器以外，开发人员可以通过继承 java.lang.ClassLoader 类的方式实现
                 自己的类加载器，以满足一些特殊的需求。
     1.3.3 Java class 文件
          平台无关性 和 网络移动性 更适应于网络。
     1.3.4 Java API ：类库
     1.3.5 Java 程序设计语言：
             面向对象，多线程，结构化错误处理，垃圾收集，动态连接，动态扩展。
             面向对象，自动垃圾收集，数组边界检查，对对象应用的检查。
   1.4 Java的体系结构的代价
   1.5 结论

第二章 平台无关（研习次:1 掌握层次：领会）

       2.1 为什么要平台无关
       2.2 Java的体系结构对平台无关的支持
           2.2.1 Java平台： 平台无关性
           2.2.2 Java语言： 提供平台无关性
           2.2.3 Java class文件：提供平台无关性
           2.2.4 可伸缩性
       2.3 影响平台无关性的因素
               2.3.1 Java平台的部署
               2.3.2 Java平台的版本
               2.3.3 本地方法
                   三种情况： 使用底层主机平台的某个特性， 访问一个已有的系统或类库，提高性能。
               2.3.4 非标准运行时库
               2.3.5 对虚拟机的依赖：
                    1） 不要依赖及时终结（finalization）来达到程序的正确性
                    2） 不要依赖线程的优先级（thread prioritization）来达到程序的正确性

                    所有的Java虚拟机都必须有垃圾回收堆(heap)，但是不同的实现可能使用不同的垃圾回收技术或算法。
                    为了保证多线程Java程序的平台独立，必须依赖同步（sychronization）而不是优先级来在线程之间协调
                    相互间的动作。
               2.3.6 对用户界面的依赖
               2.3.7 Java平台实现中的bug
        2.4 平台无关性的七个步骤：
            1） 选择程序要运行的主机和设备的集合（你的“目标宿主机”）。
            2） 在目标宿主机中选择自认为足够好的Java平台版本，在该版本Java平台上编写，运行程序。
            3） 对于每个目标宿主机，选择一些程序将要运行的Java平台实现（你的“目标运行时环境”）
            4） 编写程序，使它只通过Java API的标准运行库来访问计算机（不要调用本地方法，或者开发商专有的那些调用
                本地方法的库）
            5） 编写程序，使它不依赖垃圾回收器及时终结的正确性，也不依赖线程的优先级。
            6） 努力设计一个用户界面，使它在你所有的目标宿主机上都能正常工作。
            7） 在所有的目标运行时环境和所有的目标宿主机上测试程序。
        2.5 平台无关性的策略
        2.6 平台无关性和网络移动对象
        2.7

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

第三章 安全（研习次: 掌握层次：）

       3.1 为什么需要安全性
          沙箱，签名 ，认证信任模式
       3.2 基本沙箱
            组成Java沙箱的基本组件：
              类装载器结构，class文件检验器，内置于Java虚拟机（及语言）的安全特性， 安全管理器及Java API.
              且类装载器和安全管理器是可以由用户定制的。
（需要仔细看）  3.3 类装载器体系结构
          在三个方面对Java的沙箱起作用：
             1） 它防止恶意代码去干涉善意的代码
             2） 它守护了被信任的类库的边界
             3） 它将代码归入某类（称为保护域），该类确定了代码可以进行哪些操作。
 
       3.4 class文件检验器  -- 健壮性，
               四趟扫描完成操作：
                  第一趟扫描是在类被装载时进行的，在这次扫描中，class文件检验器检查这个class文件的内部结构，以保证它可以被安全地编译。
                  第二趟和第三趟扫描是在连接过程中进行的，在这两次扫描中，class文件检验器确认类型数据遵从Java编程语言的语义，包括检验她所包含的所有字节码的完整性。
                  第四趟扫描是在进行动态连接的过程中解析字符引用时进行的，在这次扫描中，class文件检验器确认被引用的类，字段以及方法确实存在。
   P57   ====================================================================
       3.5 Java虚拟机中内置的安全特性
            类型安全的引用转换，
            结构化的内存访问（无指针算法），
            自动垃圾收集（不必显式地释放被分配的内存），
            数组边界检查，空引用检查。

       3.6 安全管理器和Java API
       3.7 代码签名和认证
       3.8 一个代码签名示例
       3.9 策略
       3.10 保护域
       3.11 访问控制器
       3.12 Java安全模型的不足和今后的发展方向
       3.13 和体系结构无关的安全性
       3.14 资源页
       

第四章 网络移动性

       4.1 为什么需要网络移动性
       4.2 一种新的软件模式
       4.3 Java体系结构对网络移动性的支持
       4.4 applet: 网络移动性代码的示例
       4.5 Jini服务对象： 网络移动对象的示例
       4.6 网络移动性： Java设计的中心
-----------------------------------------------------------------------------------------------------------------

第五章 Java虚拟机（研习次:1 掌握层次：理解）P106 （第五章总说，后续四章从不同角度分说）

       5.1 Java虚拟机是什么（研习次:1 掌握层次：理解）P106
          Java虚拟机是如下三种不同的东西：
           1 抽象规范 如《The Java Virtual Machine Specification》 http://java.sun.com/docs/books/jvms/
           2 一个具体的实现 如 sun JDK, ibm jdk
           3 一个运行中的虚拟机实例。如 运行Tomcat
       5.2 Java虚拟机的生命周期（研习次:1 掌握层次：理解）P106
           Java虚拟机内部有两种线程：守护线程 和 非守护线程
                守护线程是由虚拟机自己使用的，比如执行垃圾收集任务的线程。
       5.3 Java虚拟机的体系结构（研习次: 掌握层次：） P107
             一个虚拟机实例的行为是分别按照：（类装载器）子系统、内存区、数据类型以及指令这个几个术语描述的。
           5.3.1 数据类型（研习次:1 掌握层次：理解） P110
                 关于finally子句，关于returnAddress的用法在第18章详细讨论
                 浮点类型的取值范围的信息参考14章
           5.3.2 字长的考量（研习次:1 掌握层次：理解） P111
                 Java虚拟机中，最基本的数据单元就是字（word）,它的大小是由每个虚拟机实现的设计者来决定的。
           5.3.3 类装载器子系统 (The Class Loader Subsystem)（研习次:1 掌握层次：理解） P112
                 在Java虚拟机中，负责查找并装载类型的那部分被称为类装载器子系统。
                 装载顺序：
                   1）装载----查找并装载类型的二进制数据。
                   2）连接----执行验证，准备，以及解析（可选)。
                         验证：确保被导入类型的正确性。
                         准备：为类变量分配内存，并将其初始化为默认值.
                         解析：把类型中的符号引用转换为直接引用。
                   3）初始化----把类变量初始化为正确初始值。
                 Java虚拟机有两种类加载器:启动类装载器和用户自定义类装载器。
                 启动类装载器是Java虚拟机实现的一部分，用户自定义类装载器则是Java程序的一部分，由不同的类装载器装载的类将被放在虚拟机内部的不同命名空间中。
                 Loading,Linking and Initialization
                 The Bootstrap Class Loader
                 User-Defined Class Loaders
                 Name Space
           5.3.4 方法区（研习次:1 掌握层次：理解） P114
                 Java虚拟机规范并没有强制规定垃圾收集器，它只要求虚拟机实现必须“以某种方式”管理自己的堆空间。
           5.3.5 堆（研习次:1 掌握层次：理解） P118
           5.3.6 程序计数器（寄存器内）（研习次:1 掌握层次：理解）P123
           5.3.7 Java栈（研习次:1 掌握层次：理解） P124
           5.3.8 栈帧（研习次:1 掌握层次：了解） P124
                 栈帧由三部分组成：局部变量区、操作数栈和帧数据区。
                   局部方法区：包含对应方法的参数和局部变量。
           5.3.9 本地方法栈（研习次:1 掌握层次：理解） P130
           5.3.10 执行引擎: （研习次:1 掌握层次：理解）P131
                  指令集 实现可以采取解释、即时编译或直接用芯片上的指令执行，还可以使他们的混合，或任何你能想到的新技术。
                  执行引擎这个术语三种解释：一个是抽象的规范，一个是具体的实现，另一个是正在运行的实例
                  Java虚拟机指令集的设计遵循几个不同的目标：
                      平台无关性:以栈为基础的结构
                      网络移动性以及
                      安全性。
                The Instruction Set：
                Execution Techniques： 解释、即时编译、自适应优化、芯片级直接执行。
                      关于执行技术要记住的最重要的一点就是，实现可以自由选择任何技术来执行字节码，只要它遵守Java虚拟机指令集的定义。
                Threads：
                     所有对基本类型的操作，除了某些对long类型和double类型的操作之外，都必须是原子级的。
           5.3.11 本地方法接口 P138
       5.4 真实机器 P139
       5.5 一个模拟“Eternal Math” P140
       5.6 随书光盘 P141

       5.7 资源页 P141

第六章 Java class文件（研习次:1 掌握层次：了解）P142：

       是一个份关于class文件格式的完整的教程和参考。如果你正在解析、生成或者比较关注Java class文件，必看
    6.1 Java class文件是什么（研习次:1 掌握层次：理解）P142
    6.2 class文件的内容（研习次:1 掌握层次：了解）P143
        ClassFile表中各项简介如下：
         （1）magic(模数)：oxCAFEBABE开头
         （2）minor_version和major_version:class文件的下面4个字节包含了，主、次版本号。
         （3）constant_pool_count和constant_pool: 在class文件中，模数和版本号后面的是常量池。
         （4）access_flags:
         （5）this_class:
          (6) super_class
          (7) interfaces_count和interfaces
          (8) fields_count和fields
          (9) methods_count和methods
          (10)attributes_count和attributes
                 SourceCode和InnerClasses
    6.3 特殊字符串（研习次:1 掌握层次：理解）P148
        常量池中容纳的符号引用包括三种特殊的字符串：全限定名、简单名称和描述符
        6.3.1 全限定名
        6.3.2 简单名称
        6.3.3 描述符
    6.4 常量池（研习次:1 掌握层次：了解）P150
        6.4.1 CONSTANT_Utf8_info表
        6.4.2 CONSTANT_Integer_info表
        6.4.3 CONSTANT_Float_info表
        6.4.4 CONSTANT_Long_info表
        6.4.5 CONSTANT_Double_info表
        6.4.6 CONSTANT_Class_info表
        6.4.7 CONSTANT_String_info表
        6.4.8 CONSTANT_Filedref_info表
        6.4.9 CONSTANT_Methodref_info表
        6.4.10 CONSTANT_InferfaceMethodref_info表 P156
        6.4.11 CONSTANT_NameAndType_info表
    6.5 字段（研习次:1 掌握层次：了解）P157
    6.6 方法（研习次:1 掌握层次：了解）P158
    6.7 属性（研习次:1 掌握层次：了解）P159
      6.7.1 属性格式
      6.7.2 Code属性
      6.7.3 ConstantValue属性
      6.7.4 Deprecated属性
      6.7.5 Exception属性
      6.7.6 InnerClasses属性
      6.7.7 LineNumberTable属性
      6.7.8 LocalVariableTable属性
      6.7.9 SourceFile属性
      6.7.10 Synthetic属性
    6.8 一个模拟:"Getting Loaded"P170
    6.9 随书光盘P172

    6.10 资源页P172

第七章(装载系统/内存管理？？？) （研习次:1 掌握层次：了解）

类型的生命周期 P174 ：讨论了类在Java虚拟机中的完整的生命周期，包括类被卸载的环境。

    7.1 类型装载、连接与初始化（研习次:1 掌握层次：了解）P174
       Loading: 就是把二进制形式的Java类型读入Java虚拟机中；
       Linking：就是把这种已经读入虚拟机的二进制形式的类型数据合并到虚拟机的运行时状态中去。
         Verification：确保了Java类型数据格式正确并且适于Java虚拟机使用。
         Preparation：负责为该类型分配它所需的内存，比如为它的类变量分配内存.
         Resolution:负责把常量池中的符号引用转换为直接引用，虚拟机的实现可以推迟解析这一步。
       Initialization：将给类变量赋以适当的初始值。
         The Class Initialization Method： 每个类或接口首次主动使用时初始化：
             当创建某个类得新实例时（或者通过在字节码中执行new指令；或者通过不明确的创建、反射、克隆或者反序列化）
             当调用某个类得静态方法时（即在字节码中执行invokestatic指令时）
             当使用某个类或接口的静态字段，或者对该字段赋值时（即在字节码中，执行getstatic或putstatic指令时），用final修饰的静态字段除外，它被初始化为一个编译时的常量表达式。
             当调用Java API中的某些反射方法时，比如类Class中的方法或者java.lang.reflect包中的类的方法
             当初始化某个类的子类时（某个类初始化时，要求它的超类已经被初始化了）
             当虚拟机启动时某个被标明为启动类的类（即含有main()方法的那个类）
         Active versus Passive Use：除了上述六种情形外，所有其他使用Java类型的方式都是被动使用，他们都不会导致Java类型的初始化。
        7.1.1 装载P175
          装载阶段有三个基本动作组成，要装载一个类型，Java虚拟机必须：
             通过该类型的完全限定名，产生一个代表该类型的二进制数据流。
             解析这个二进制数据流为方法区内的内部数据结构
             创建一个表示该类型的java.lang.Class类得实例
         7.1.2 验证(连接的第一步）P176
         7.1.3 准备(连接的第二步)P178
         7.1.4 解析(连接的第三步)P178
        7.1.5 初始化P179
          1. <clinit>()方法P180
          2. 主动使用和被动使用P183
    7.2 对象的生命周期（研习次:1 掌握层次：了解）P185
      7.2.1 类实例化（研习次:1 掌握层次：了解）P185
          实例化一个类有四种途径：
             明确地使用new操作符；
             调用Class或者java.lang.reflect.Constructor对象的newInstance()方法；
             调用任何现有对象的clone()方法；
             或者通过java.io.ObjectStream类的getObject()方法反序列化；
      7.2.2 垃圾收集和对象的终结（研习次:1 掌握层次：了解）P195
    7.3 卸载类型（研习次:1 掌握层次：了解）P196
    7.4 随书光盘P197
    7.5 资源页P197

第八章 （连接系统）连接模型 P198 ：

完整解释了Java的连接模型，包括使用forName()和类装载器的例子，以便在运行时用新类型对Java使用程序进行动态扩展。

    8.1 动态连接和解析（研习次:1 掌握层次：了解）P198
      8.1.1 解析和动态扩展（研习次:1 掌握层次：了解）P199
           动态扩展Java程序的方式：
            1 Class：forName(String className) 和 forName(String name, boolean initialize, ClassLoader loader)
            2 ClassLoader: 使用用户自定义类装载器的loadClass()方法。
      8.1.2 类装载器与双亲委派模型（研习次:1 掌握层次：了解）P202
      8.1.3 常量池解析P203
      8.1.4 解析CONSTANT_Class_info入口P203
      8.1.5 解析CONSTANT_Fieldl_info入口P208
      8.1.6 解析CONSTANT_Methodref_info入口P209
      8.1.7 解析CONSTANT_InterfaceMethodref_info入口P210
      8.1.8 解析CONSTANT_String_info入口P210
      8.1.9 解析其他类型的入口
      8.1.10 装载约束P212
      8.1.11 编译时常量解析
      8.1.12 直接引用P214
      8.1.13 _quick指令P220
      8.1.14 示例：Salutation程序的连接P221
      8.1.15 示例：Greet程序的动态扩展
      8.1.16 使用1.1版本的用户自定义类装载器P234
      8.1.17 使用1.2版本的用户自定义类装载器P239
      8.1.18 示例：使用forName()的动态扩展P243
      8.1.19 示例：卸载无法触及的greeter类P245
      8.1.20 示例：类型安全性与装载约束P250
    8.2 随书光盘
    8.3 资源页P258

第九章 垃圾收集 （研习次:1 掌握层次：了解）：

讨论了垃圾回收和中介（finalization）,揭示了说明是软、弱和影子引用，也提出了如何使用终结方法。

    9.1 为什么要使用垃圾收集?（研习次:1 掌握层次：了解） P260
    9.2 垃圾收集算法?（研习次:1 掌握层次：理解）P261
         任何垃圾收集算法都必须做两件事情：
           首先，它必须检测出垃圾对象。 其次，它必须回收垃圾对象锁使用的堆空间并还给程序。
           区分活动对象和垃圾的两个方法是引用计数和跟踪。
    9.3 引用计数收集器（研习次:1 掌握层次：理解）P262
    9.4 跟踪收集器（研习次:1 掌握层次：理解）P262
           基本的追踪算法被称为"标记并清除"
    9.5 压缩收集器（研习次:1 掌握层次：理解）P262
           标记并清除收集器通常使用的两种策略是压缩和拷贝。
    9.6 拷贝收集器（研习次:1 掌握层次：理解）P262
           一般的拷贝收集器算法被称为"停止并拷贝"
    9.7 按代收集的收集器（研习次:1 掌握层次：理解）P263
           按代进行的收集技术除了可以应用于拷贝算法，也可以应用于标记并清除算法。不管在那种情况下，把堆按照对象年龄层分解都可以提高最基本的垃圾收集算法的性能。
    9.8 自适应收集器（研习次:1 掌握层次：理解）P264
    9.9 火车算法（研习次:1 掌握层次：理解）P264  ：渐进式收集算法 主要收集Perm区垃圾回收
          垃圾收集算法和明确释放对象比起来有一个潜在的缺点，即垃圾收集算法中程序员对安排CPU时间进行内存回收缺乏控制。
          要精确地预测出何时（甚至是否）进行垃圾收集、收集需要多长时间，基本上都是不可能的。因为垃圾收集一般都会停止整个程序的运行来查找和收集垃圾对象，
          垃圾收集也可能使得程序对时间响应迟钝，无法满足实时系统的要求。这种垃圾收集算法有破坏性。
        达到（或者试图达到）非破坏性垃圾收集的方法是使用渐进式收集算法。渐进式收集算法：不试图一次性发现并回收所有不可触及的对象，而是每次发现并回收一部分。因为每次都只有堆的一部分执行垃圾收集，因此理论上说每一次收集会持续更短的时间。
      9.9.1 车厢、火车和火车站P265
           火车算法把成熟对象空间（Perm区）划分为固定长度的内存块，算法每次在一个块中单独执行。
      9.9.2 车厢收集P266
      9.9.3 记忆集合和流行对象P267
    9.10 终结（研习次:1 掌握层次：理解） P267
    9.11 对象可触及性的生命周期P268
         在垃圾回收器看来，堆中的每一个对象都有三种状态之一：可触及的（强可触及），可复活的，以及不可触及的。
         扩充三种新的状态：软可触及，弱可触及，以及影子可触及。
      9.11.1 引用对象（研习次:1 掌握层次：理解）P269
      9.11.2 可触及性状态的变化（研习次:1 掌握层次：理解）P270
      9.11.3 缓存、规范映射和临终清理（研习次:1 掌握层次：了解）P272
    9.12 一个模拟:"Heap of Fish"P273
      9.12.1 分配鱼P274
      9.12.2 设置引用P275
      9.12.3 垃圾收集P276
      9.12.4 压缩堆P277
    9.13 随书光盘P279
    9.14 资源页P278
-----------------------------------------------------------------------------------------------------------------
指令集架构(ISA，Instruction Set Architecture)是与程序设计有关的计算机架构的一部分。
  包括本地数据类型、指令、寄存器、地址模式、内存架构、中断和意外处理和外部 I/O 。
  一个ISA包括一系列opcodes（机器语言）的一个规格，本地命令由一个特定的CPU设计来实现。
  指令集架构：http://zh.wikipedia.org/zh-cn/%E6%8C%87%E4%BB%A4%E9%9B%86
              http://baike.baidu.com/view/1119651.htm

--第10-19章是关于java虚拟机指令集的教程

执行引擎的抽象规范是根据指令集来定义的，（第10章到第20章）是此指令集的说明手册--------------------------------

第十章 栈和局部变量操作

    10.1 常量入栈操作
    10.2 通用栈操作
    10.3 把局部变量压入栈
    10.4 弹出栈顶部元素，将其赋给局部变量

    10.5 wide指令

第十一章 类型转换

    11.1 类型操作码

第十二章 整数运算

    12.1 二进制补码运算
    12.2 Inner Int:揭示Java int类型内部性质的applet

    12.3 运算操作码

第十三章 逻辑运算

    13.1 逻辑操作码

第十四章 浮点运算

    14.1 浮点数
    14.2 Inner Float:揭示Java float类型内部性质的applet
    14.3 浮点模式:
      14.3.1 浮点值集合
      14.3.2 浮点值集的转换
      14.3.3 相关规则的本质

    14.4 浮点操作码

第十五章 对象和数组

    15.1 关于对象和数组的回顾
    15.2 针对对象的操作码

    15.3 针对数组的操作码

第十六章 控制流

    16.1 条件分支
    16.2 无条件分支

    16.3 使用表的条件分支

第十七章 异常

    17.1 异常的抛出与捕获

    17.2 异常表

第十八章 finaly子句P342

    18.1 微型子例程P342

    18.2 不对称的调用和返回P343

第十九章 方法的调用与返回

    19.1 方法调用
      19.1.1 Java方法的调用
      19.1.2 本地方法的调用
    19.2 方法调用的其他形式
    19.3 指令invokespecial
      19.3.1 指令invokespecial和<init>()方法
      19.3.2 指令invokespecial和私有方法
      19.3.3 指令invokespecial和super关键字
    19.4 指令invokeinterface
    19.5 指令的调用和速度
    19.6 方法调用的实例

    19.7 从方法中返回

第二十章 线程同步 P364：

揭示了什么叫做监视器，以及如何使用他们编写线程安全的java代码。

    20.1 监视器P364
         Java中的监视器支持两种线程：互斥和协作。 Java虚拟机通过对象锁来实现互斥，允许多个线程在同一个共享数据上独立二互不干扰地工作。
         协作则是通过Object类得wait方法和notify方法来实现，允许多个线程为了一个目标而共同工作。
    20.2 对象锁P367
    20.3 指令集中对同步的支持P368
      30.3.1 同步语句P368
      30.3.2 同步方法P371

    20.4 Object类中的协调支持P374

参考资料:

http://www.artima.com/jvm/booklist.html
《Inside the Java Virtual Machine 2version》        http://www.artima.com/insidejvm/ed2/index.html
《The Java Virtual Machine Specification 第二版/第三版》          http://java.sun.com/docs/books/jvms/
  Java虚拟机原理和优化：http://developer.51cto.com/art/201001/176550.htm
《Oracle JRockit-The Definitive Guide》另一款Java虚拟机
  Books about the Java Virtual Machine：http://www.artima.com/jvm/booklist.html
 《Inside the Java 2 Virtual Machine》
 《Java Virtual Machine Specification Second Edition》
 《The Java Virtual Machine》
   Books about Garbage Collection：http://www.artima.com/jvm/booklist.html
 《Garbage Collection: Algorithms for Automatic Dynamic Memory Management》
   Books about Threads：http://www.artima.com/jvm/booklist.html
 《Concurrent Programming in Java: Design Principles and Patterns》
 《Java Threads》
   Books about Java Security：http://www.artima.com/jvm/booklist.html
 《Security (from Inside the Java 2 Virtual Machine)》
 《Securing Java: Getting Down to Business With Mobile Code》
 《Java Security》
 《Inside Java 2 Platform Security》
 《深入理解Java虚拟机-JVM高级特性与最佳实践》
  淘宝网 莫枢 http://rednaxelafx.iteye.com/
             http://rednaxelafx.iteye.com/blog/656951 视频分享
             http://bluedavy.com/?p=36                杭州程序员圆桌交流第二期视频
             http://blog.bluedavy.com/?p=74           杭州程序员圆桌交流第三期：GC Tuning Case
    * The Java Virtual Machine Specification by Tim Lindholm and Frank Yellin (Addison-Wesley)
    * Inside the Java Virtual Machine by Bill Venners (McGraw-Hill)
    * Java Virtual Machine by Jon Meyer and Troy Downing (O'Reilly)

    * The official (JavaSoft) Java Virtual Machine Specification, which is based on the book reviewed this month http://java.sun.com/docs/books/vmspec/html/VMSpecTOC.doc.html
    * Motorola's menu of electronic components, which includes entries to their range of microprocessor products http://mot-sps.com/sps/General/chips-nav.html
    * Intel's Pentium II pages http://www.intel.com/PentiumII/home.htm?iid={spotlight=333_text}
    * Hewlett-Packard's hand-held calculators home page http://www.hp.com/calculators/
    * A comprehensive archive on Inmos's Transputer information http://www.comlab.ox.ac.uk/archive/transputer/
    * Phil Koopman's pages on stack-based processors, which includes the full text of a book written by Phil http://www.cs.cmu.edu/afs/cs.cmu.edu/user/koopman/WWW/stack.html
    * A listing of all Laurence's book reviews for JavaWorld http://www.javaworld.com/common/jw-ti-bookreviews.html
工具：
 Eclipse Memory Analyzer： http://www.eclipse.org/mat/