jvm常量编译

1. java程序运行的五个步骤

1、Java程序从源文件创建到程序运行要经过两大步骤：1、源文件由编译器编译成字节码（ByteCode） 2、字节码由java虚拟机解释运行。因为java程序既要编译同时也要经过JVM的解释运行，所以说Java被称为半解释语言（"semi-interpreted" language）。

第一步(编译): 创建完源文件之后，程序会先被编译为.class文件。Java编译一个类时，如果这个类所依赖的类还没有被编译，编译器就会先编译这个被依赖的类，然后引用，否则直接引用，这个有点像make。如果java编译器在指定目录下找不到该类所其依赖的类的.class文件或者.java源文件的话，编译器话报“cant find symbol”的错误。

编译后的字节码文件格式主要分为两部分：常量池和方法字节码。常量池记录的是代码出现过的所有token(类名，成员变量名等等)以及符号引用（方法引用，成员变量引用等等）；方法字节码放的是类中各个方法的字节码。

第二步（运行）：java类运行的过程大概可分为两个过程：1、类的加载 2、类的执行。需要说明的是：JVM主要在程序第一次主动使用类的时候，才会去加载该类。也就是说，JVM并不是在一开始就把一个程序就所有的类都加载到内存中，而是到不得不用的时候才把它加载进来，而且只加载一次。

2、下面是程序运行的详细步骤：

• 在编译好java程序得到Main.class文件后，在命令行上敲java Main。系统就会启动一个jvm进程，jvm进程从classpath路径中找到一个名为Main.class的二进制文件，将Main的类信息加载到运行时数据区的方法区内，这个过程叫做Main类的加载。

• 然后JVM找到Main的主函数入口，开始执行main函数。

• main函数的第一条命令是Animal animal = new Animal("Puppy");就是让JVM创建一个Animal对象，但是这时候方法区中没有Animal类的信息，所以JVM马上加载Animal类，把Animal类的类型信息放到方法区中。

• 加载完Animal类之后，Java虚拟机做的第一件事情就是在堆区中为一个新的Animal实例分配内存, 然后调用构造函数初始化Animal实例，这个Animal实例持有着指向方法区的Animal类的类型信息（其中包含有方法表，java动态绑定的底层实现）的引用。

• 当使用animal.printName()的时候，JVM根据animal引用找到Animal对象，然后根据Animal对象持有的引用定位到方法区中Animal类的类型信息的方法表，获得printName()函数的字节码的地址。

• 开始运行printName()函数。

2. jvm静态变量为什么要在准备阶段提前分配内存

静态变量是在类加载的时候分配空间的，静态变量和对象没有关系 是在JVM第一次读到一个类的时候加载信息的过程中分配空间的 加载过程为

1 .加载父类（如果父类已经加载过，则不在加载）。

2.初始化静态属性 。

3 .按顺序的初始化静态代码块 初始化的前提就是分配空间 。

而且静态变量在以后的创建对象的时候不在初始化 所以一般用静态来保存共享信息

• 静态变量存在于方法区中，成员变量存在于堆内存中，成员变量所属于对象JAVA成员变量和静态变量的区别，成员变量随着对象创建而存在。随着对象被回收而消失。静态变量随着类的加载而存在。

• 静态变量是属于静态存储方式，但是属于静态存储方式的量不一定就是静态变量，例如外部变量虽属于静态存储方式，但不一定是静态变量，必须由static加以定义后才能成为静态外部变量，或称静态全局变量。

• 静态变量也可以用于存储常数。具体来说，静态变量可用const，constant或final等关键字标识，这时其值就会在编译时设定，并且无法在运行时改变。编译器通常将静态常量与文本一起置于目标文件的文本区域，而非常量初始化数据则置于数据区。

3. 谁能简单阐述下java编译执行的过程

Java虚拟机(JVM)是可运行Java代码的假想计算机。

只要根据JVM规格描述将解释器移植到特定的计算机上，就能保证经过编译的任何Java代码能够在该系统上运行。

本文首先简要介绍从Java文件的编译到最终执行的过程，随后对JVM规格描述作一说明。

一.Java源文件的编译、下载、解释和执行

Java应用程序的开发周期包括编译、下载、解释和执行几个部分。

Java编译程序将Java源程序翻译为JVM可执行代码?字节码。

这一编译过程同C/C++的编译有些不同。

当C编译器编译生成一个对象的代码时，该代码是为在某一特定硬件平台运行而产生的。

因此，在编译过程中，编译程序通过查表将所有对符号的引用转换为特定的内存偏移量，以保证程序运行。

Java编译器却不将对变量和方法的引用编译为数值引用，也不确定程序执行过程中的内存布局，而是将这些符号引用信息保留在字节码中，由解释器在运行过程中创立内存布局，然后再通过查表来确定一个方法所在的地址。

这样就有效的保证了Java的可移植性和安全性。

运行JVM字节码的工作是由解释器来完成的。

解释执行过程分三部进行：代码的装入、代码的校验和代码的执行。

装入代码的工作由"类装载器"（classloader）完成。

类装载器负责装入运行一个程序需要的所有代码，这也包括程序代码中的类所继承的类和被其调用的类。

当类装载器装入一个类时，该类被放在自己的名字空间中。

除了通过符号引用自己名字空间以外的类，类之间没有其他办法可以影响其他类。

在本台计算机上的所有类都在同一地址空间内，而所有从外部引进的类，都有一个自己独立的名字空间。

这使得本地类通过共享相同的名字空间获得较高的运行效率，同时又保证它们与从外部引进的类不会相互影响。

当装入了运行程序需要的所有类后，解释器便可确定整个可执行程序的内存布局。

解释器为符号引用同特定的地址空间建立对应关系及查询表。

通过在这一阶段确定代码的内存布局，Java很好地解决了由超类改变而使子类崩溃的问题，同时也防止了代码对地址的非法访问。

随后，被装入的代码由字节码校验器进行检查。

校验器可发现操作数栈溢出，非法数据类型转化等多种错误。

通过校验后，代码便开始执行了。

Java字节码的执行有两种方式：

1.即时编译方式：解释器先将字节码编译成机器码，然后再执行该机器码。

2.解释执行方式：解释器通过每次解释并执行一小段代码来完成Java字节码程序的所有操作。

通常采用的是第二种方法。

由于JVM规格描述具有足够的灵活性，这使得将字节码翻译为机器代码的工作

具有较高的效率。

对于那些对运行速度要求较高的应用程序，解释器可将Java字节码即时编译为机器码，从而很好地保证了Java代码的可移植性和高性能。

二.JVM规格描述

JVM的设计目标是提供一个基于抽象规格描述的计算机模型，为解释程序开发人员提很好的灵活性，同时也确保Java代码可在符合该规范的任何系统上运行。

JVM对其实现的某些方面给出了具体的定义，特别是对Java可执行代码，即字节码(Bytecode)的格式给出了明确的规格。

这一规格包括操作码和操作数的语法和数值、标识符的数值表示方式、以及Java类文件中的Java对象、常量缓冲池在JVM的存储映象。

这些定义为JVM解释器开发人员提供了所需前散的信息和开发环境。

Java的设计者希望给开发人员以随心所欲使用Java的自由。

JVM定义了控制Java代码解释执行纤悔码和具体实现的五种规格，它们是：

JVM指令系统

JVM寄存器

JVM栈结构

JVM碎片回收堆

JVM存储区

2.1JVM指令系统

JVM指令系统同其他计算机的指令系统极其相似。

Java指令也是由操作码和操作数两部分组成。

操作码为8位二进制数，操作数进紧随在操作码的后面，其长度根据需要而不同。

操作毁哪码用于指定一条指令操作的性质（在这里我们采用汇编符号的形式进行说明），如iload表示从存储器中装入一个整数，anewarray表示为一个新数组分配空间，iand表示两个整数的"与"，ret用于流程控制，表示从对某一方法的调用中返回。

当长度大于8位时，操作数被分为两个以上字节存放。

JVM采用了"bigendian"的编码方式来处理这种情况，即高位bits存放在低字节中。

这同Motorola及其他的RISCCPU采用的编码方式是一致的，而与Intel采用的"littleendian"的编码方式即低位bits存放在低位字节的方法不同。

Java指令系统是以Java语言的实现为目的设计的，其中包含了用于调用方法和监视多先程系统的指令。

Java的8位操作码的长度使得JVM最多有256种指令，目前已使用了160多种操作码。

2.2JVM指令系统

所有的CPU均包含用于保存系统状态和处理器所需信息的寄存器组。

如果虚拟机定义较多的寄存器，便可以从中得到更多的信息而不必对栈或内存进行访问，这有利于提高运行速度。

然而，如果虚拟机中的寄存器比实际CPU的寄存器多，在实现虚拟机时就会占用处理器大量的时间来用常规存储器模拟寄存器，这反而会降低虚拟机的效率。

针对这种情况，JVM只设置了4个最为常用的寄存器。

它们是：

pc程序计数器

optop操作数栈顶指针

frame当前执行环境指针

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

所有寄存器均为32位。

pc用于记录程序的执行。

optop,frame和vars用于记录指向Java栈区的指针。

2.3JVM栈结构

作为基于栈结构的计算机，Java栈是JVM存储信息的主要方法。

当JVM得到一个Java字节码应用程序后，便为该代码中一个类的每一个方法创建一个栈框架，以保存该方法的状态信息。

每个栈框架包括以下三类信息：

局部变量

执行环境

操作数栈

局部变量用于存储一个类的方法中所用到的局部变量。

vars寄存器指向该变量表中的第一个局部变量。

执行环境用于保存解释器对Java字节码进行解释过程中所需的信息。

它们是：上次调用的方法、局部变量指针和操作数栈的栈顶和栈底指针。

执行环境是一个执行一个方法的控制中心。

例如：如果解释器要执行iadd(整数加法)，首先要从frame寄存器中找到当前执行环境，而后便从执行环境中找到操作数栈，从栈顶弹出两个整数进行加法运算，最后将结果压入栈顶。

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

2.4JVM碎片回收堆

Java类的实例所需的存储空间是在堆上分配的。

解释器具体承担为类实例分配空间的工作。

解释器在为一个实例分配完存储空间后，便开始记录对该实例所占用的内存区域的使用。

一旦对象使用完毕，便将其回收到堆中。

在Java语言中，除了new语句外没有其他方法为一对象申请和释放内存。

对内存进行释放和回收的工作是由Java运行系统承担的。

这允许Java运行系统的设计者自己决定碎片回收的方法。

在SUN公司开发的Java解释器和HotJava环境中，碎片回收用后台线程的方式来执行。

这不但为运行系统提供了良好的性能，而且使程序设计人员摆脱了自己控制内存使用的风险。

2.5JVM存储区

JVM有两类存储区：常量缓冲池和方法区。

常量缓冲池用于存储类名称、方法和字段名称以及串常量。

方法区则用于存储Java方法的字节码。

对于这两种存储区域具体实现方式在JVM规格中没有明确规定。

这使得Java应用程序的存储布局必须在运行过程中确定，依赖于具体平台的实现方式。

JVM是为Java字节码定义的一种独立于具体平台的规格描述，是Java平 *** 立性的基础。

目前的JVM还存在一些限制和不足，有待于进一步的完善，但无论如何，JVM的思想是成功的。

对比分析：如果把Java原程序想象成我们的C++原程序，Java原程序编译后生成的字节码就相当于C++原程序编译后的80x86的机器码（二进制程序文件），JVM虚拟机相当于80x86计算机系统,Java解释器相当于80x86CPU。

在80x86CPU上运行的是机器码，在Java解释器上运行的是Java字节码。

Java解释器相当于运行Java字节码的“CPU”,但该“CPU”不是通过硬件实现的，而是用软件实现的。

Java解释器实际上就是特定的平台下的一个应用程序。

只要实现了特定平台下的解释器程序，Java字节码就能通过解释器程序在该平台下运行，这是Java跨平台的根本。

当前，并不是在所有的平台下都有相应Java解释器程序，这也是Java并不能在所有的平台下都能运行的原因，它只能在已实现了Java解释器程序的平台下运行。

4. java中如何定义常量

在Java中定义常量可以通过普通类中使用static final修饰变量的方法。

final关键字使用的范围。这个final关键字不仅可以用来修饰基本数据类型的常量，还可以用来修饰对象的引用或者方法。如数组就是一 个对象引用。为此可以使用final关键字来定义一个常量的数组。这就是Java语言中一个很大的特色。

一旦一个数组对象被final关键字设置为常量数 组之后，它只能够恒定的指向一个数组对象，无法将其改变指向另外一个对象，也无法更改数组（有序数组的插入方法可使用的二分查找算法）中的值。

(4)jvm常量编译扩展阅读：

关于Java中的常量：

final：一个常量，或不能覆盖的一个类或方法。

interface：接口，一种抽象类型，仅有方法和常量的定义

5. 简述jvm工作原理

Java是一种技术，它由四方面组成：Java编程语言、Java类文件格式、Java虚拟机和Java应用程序接口(Java API)。

运行期环境代表着Java平台，开发人员编写Java代码(.java文件)，然后将之编译成字节码(.class文件)，再然后字节码被装入内存，一旦字节码进入虚拟机，它就会被解释器解释执行，或者是被即时代码发生器有选择的转换成机器码执行。

Java平台由Java虚拟机和Java应用程序接口搭建，Java语言则是进入这个平台的通道，用Java语言编写并编译的程序可以运行在这个平台上。

在Java平台的结构中, 可以看出，Java虚拟机(JVM) 处在核心的位置，是程序与底层操作系统和硬件无关的关键。它的下方是移植接口，移植接口由两部分组成：适配器和Java操作系统, 其中依赖于平台的部分称为适配器；JVM 通过移植接口在具体的平台和操作系统上实现；在JVM 的上方是Java的基本类库和扩展类库以及它们的API， 利用Java API编写的应用程序(application) 和小程序(Java applet) 可以在任何Java平台上运行而无需考虑底层平台, 就是因为有Java虚拟机(JVM)实现了程序与操作系统的分离，从而实现了Java 的平台无关性。

JVM在它的生存周期中有一个明确的任务，那就是运行Java程序，因此当Java程序启动的时候，就产生JVM的一个实例；当程序运行结束的时候，该实例也跟着消失了。下面我们从JVM的体系结构和它的运行过程这两个方面来对它进行比较深入的研究。

1、Java虚拟机的体系结构

·每个JVM都有两种机制：

①类装载子系统：装载具有适合名称的类或接口

②执行引擎：负责执行包含在已装载的类或接口中的指令

·每个JVM都包含：

方法区、Java堆、Java栈、本地方法栈、指令计数器及其他隐含寄存器

2、Java代码编译和执行的整个过程

也正如前面所说，Java代码的编译和执行的整个过程大概是：开发人员编写Java代码(.java文件)，然后将之编译成字节码(.class文件)，再然后字节码被装入内存，一旦字节码进入虚拟机，它就会被解释器解释执行，或者是被即时代码发生器有选择的转换成机器码执行。

（1）Java代码编译是由Java源码编译器来完成，也就是Java代码到JVM字节码（.class文件）的过程。

2）Java字节码的执行是由JVM执行引擎来完成

Java代码编译和执行的整个过程包含了以下三个重要的机制:

·Java源码编译机制

·类加载机制

·类执行机制

 

（1）Java源码编译机制

Java 源码编译由以下三个过程组成：

①分析和输入到符号表

②注解处理

③语义分析和生成class文件

最后生成的class文件由以下部分组成：

①结构信息：包括class文件格式版本号及各部分的数量与大小的信息

②元数据：对应于Java源码中声明与常量的信息。包含类/继承的超类/实现的接口的声明信息、域与方法声明信息和常量池

③方法信息：对应Java源码中语句和表达式对应的信息。包含字节码、异常处理器表、求值栈与局部变量区大小、求值栈的类型记录、调试符号信息

（2）类加载机制 JVM的类加载是通过ClassLoader及其子类来完成的

6. JVM原理是什么

首先这里澄清两个概念：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类或者System.exit()来退出。JVM是什么？—JVM的体系结构粗略分来，JVM的内部体系结构分为三部分，分雹山别是：类装载器（ClassLoader）子系统，运行时数据区，和执行引擎。下面将先介绍类装载器，然后是执行引擎，最后是运行时数据区1、类装载器，顾名思义，就是用来装载.class文件的。JVM的两种类装载器包括：启动类装载器和用户自定义类装载器，启动类装载器是JVM实现的一部分，用户自定义类装载器则是Java程序的一部分，必须是ClassLoader类的子类。（下面所述情况是针对SunJDK1.2）动类装载器：只在系统类(JavaAPI的类文件)的安装路径查找要装入的类用户自定义类装载器：系统类装载器：在JVM启动时创建，用来在CLASSPATH目录下查找要装入的类其他用户自定义类装载器：这里有必要先说一下ClassLoader类的几个方法，了解它们对于了解自定义类装载器如何装载.class文件至关重要。(Stringname,bytedata[],intoffset,intlength) (Stringname,bytedata[],intoffset,intlength,);(Stringname) (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使用的是大端序（big?endian:即低字节的数据存储在高位内存上，如对于1234，12是高位数据，34为低位数据，则Java中的存储格式应该为12存在内存的低地址，34存在内存的高地址，x86中的存储格式与之相反）来存储数据，这实际上是在class文件中数据的存储格式，但是当数据倒入到方法区中时，JVM可以以任何方式来存储它。类型信息：包括class的全限定名，class的直接父类，类类型还是接口类型，类的修饰符（public,等），所有直接父接口的列表，Class对象提供了访问这些信息的窗口（可通过Class.forName(“”)或instance.getClass()获得），下面是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(); lava.flow(); } } 运行命令JavaVolcano;（1）JVM找到Volcano.class倒入，并提取相应的类型信息到方法区。通过执行方法区中的字节码，JVM执行main（）方法，（执行时会一直保存指向Vocano类的常量池的指针）（2）Main（）中第一条指令告诉JVM需为列在常量池第一项的类分配内存（此处再次说明了常量池并非只存储常量信息），然后JVM找到常量池的第一项，发现是对Lava类的符号引用，则检查方法区，看Lava类是否装载，结果是还未装载，则查找“Lava.class”,将类型信息写入方法区，并将方法区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是什么了吧。原文链接： http://www.cnblogs.com/chenzhao/archive/2011/08/14/2137713.html

7. 深入Java核心 Java内存分配原理精讲

Java内存分配与管理是Java的核心技术之一，今天我们深入Java核心，详细介绍一下Java在内存分配方面的知识。一般Java在内存分配时会涉及到以下区域：
◆寄存器：我们在程序中无法控制
◆栈：存放基本类型的数据和对象的引用，但对象本身不存放在栈中，而是存放在堆中
◆堆：存放用new产生的数据
◆静态域：存放在对象中用static定义的静态成员
◆常量池：存放常量
◆非RAM存储：硬盘等永久存储空间
Java内存分配中的栈
在函数中定义的一些基本类型的变量数据和对象的引用变量都在函数的栈内存中分配。
当在一段代码块定义一个变量时，Java就在栈中 为这个变量分配内存空间，当该变量退出该作用域后，Java会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。
Java内存分配中的堆
堆内存用来存放由new创建的对象和数组。 在堆中分配的内存，由Java虚拟机的自动垃圾回收器来管理。
在堆中产生了一个数组或对象弊纯后，还可以 在栈中定义一个特殊的变量，让栈中这个变量的取值等于数组或对象在堆内存中的首地址，栈中的这个变量就成了数组或租渣咐对象的引用变量。 引用变量就相当于是 为数组或对象起的一个名称，以后就可以在程序中使用栈中的引用变量来访问堆中的数组或对象。引用变量就相当于是为数组或者对象起的一个名称。
引用变量是普通的变量，定义时在栈中分配，引用变量在程序运行到其作用域之外后被释放。而数组和对象本身在堆中分配，即使程序 运行到使用 new 产生数组或者对象的语句所在的代码块之外，数组和对象本身占据的内存不会被释放，数组和对象在没有引用变量指向它的时候，才变为垃圾，不能在被使用，但仍 然占据内存空间不放，在随后的一个不确定的时间被垃圾回收器收走（释放掉）。这也是 Java 比较占内存的原因。
实际上，栈中的变量指向堆内存中的变量，这就是Java中的指针！
常量池 (constant pool)
常量池指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。除了包含代码中所定义的各种基本类型（如int、long等等）和对象型（如String及数组）的常量值(final)还包含一些以文本形式出现的符号引用，比如：
◆类和接口的全限定名；
◆字段的名称和描述符；
◆方法和名称和描述符。
虚拟机必须为每个被装载的类型维护一个常量池。常量池就是该类型所用到常量的一个有序集和，包括直接常量（string,integer和 floating point常量）和对其他类型，字段和方法的符号引用。
对于String常量，它的值是在常量池中的。而JVM中的常量池在内存当中是以表的形式存在的， 对于String类型，有一张固定长度的CONSTANT_String_info表用来存储文字字符串值，注意：该表只存储文字字符串值，不存储符号引 用。说到这里，对常量池中的字符串值的存储位置应该有一个比较明了的理解了。
在程序执行的时候,常量池 会储存在Method Area,而不是堆中。
堆与栈
Java的堆是一个运行时数据区,类的(对象从中分配空间。这些对象通过new、newarray、 anewarray和multianewarray等指令建立，它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存 大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态 分配内存，存取速度较慢。
栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是 确定的，缺乏灵活性。栈中主要存放一些基本类型的变量数据（int, short, long, byte, float, double, boolean, char）和对象句柄(引用)。
栈有一个很重要的特殊性，就是存在栈中的数据可以共享。假设我们同时定义：
int a = 3; int b = 3； 编译器先处理int a = 3；梁桐首先它会在栈中创建一个变量为a的引用，然后查找栈中是否有3这个值，如果没找到，就将3存放进来，然后将a指向3。接着处理int b = 3；在创建完b的引用变量后，因为在栈中已经有3这个值，便将b直接指向3。这样，就出现了a与b同时均指向3的情况。
这时，如果再令 a=4；那么编译器会重新搜索栈中是否有4值，如果没有，则将4存放进来，并令a指向4；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响 到b的值。
要注意这种数据的共享与两个对象的引用同时指向一个对象的这种共享是不同的，因为这种情况a的修改并不会影响到b, 它是由编译器完成的，它有利于节省空间。而一个对象引用变量修改了这个对象的内部状态，会影响到另一个对象引用变量。
String是一个特殊的包装类数据。可以用：
String str = new String("abc"); String str = "abc"; 两种的形式来创建，第一种是用new()来新建对象的，它会在存放于堆中。每调用一次就会创建一个新的对象。而第二种是先在栈中创建一个对String类的对象引用变量str，然后通过符号引用去字符串常量池 里找有没有"abc",如果没有，则将"abc"存放进字符串常量池 ，并令str指向”abc”，如果已经有”abc” 则直接令str指向“abc”。
比较类里面的数值是否相等时，用equals()方法；当测试两个包装类的引用是否指向同一个对象时，用==，下面用例子说明上面的理论。
String str1 = "abc"; String str2 = "abc"; System.out.println(str1==str2); //true 可以看出str1和str2是指向同一个对象的。
String str1 =new String ("abc"); String str2 =new String ("abc"); System.out.println(str1==str2); // false 用new的方式是生成不同的对象。每一次生成一个。
因此用第二种方式创建多个”abc”字符串,在内存中 其实只存在一个对象而已. 这种写法有利与节省内存空间. 同时它可以在一定程度上提高程序的运行速度，因为JVM会自动根据栈中数据的实际情况来决定是否有必要创建新对象。而对于String str = new String("abc")；的代码，则一概在堆中创建新对象，而不管其字符串值是否相等，是否有必要创建新对象，从而加重了程序的负担。
另 一方面, 要注意: 我们在使用诸如String str = "abc"；的格式定义类时，总是想当然地认为，创建了String类的对象str。担心陷阱！对象可能并没有被创建！而可能只是指向一个先前已经创建的 对象。只有通过new()方法才能保证每次都创建一个新的对象。
由于String类的immutable性质，当String变量需要经常变换 其值时，应该考虑使用StringBuffer类，以提高程序效率。
1. 首先String不属于8种基本数据类型，String是一个对象。因为对象的默认值是null，所以String的默认值也是null；但它又是一种特殊的对象，有其它对象没有的一些特性。
2. new String()和new String(”")都是申明一个新的空字符串，是空串不是null；
3. String str=”kvill”；String str=new String (”kvill”)的区别
示例：
String s0="kvill"; String s1="kvill"; String s2="kv" + "ill"; System.out.println( s0==s1 ); System.out.println( s0==s2 ); 结果为：
true
true
首先，我们要知结果为道Java 会确保一个字符串常量只有一个拷贝。
因为例子中的 s0和s1中的”kvill”都是字符串常量，它们在编译期就被确定了，所以s0==s1为true；而”kv”和”ill”也都是字符串常量，当一个字 符串由多个字符串常量连接而成时，它自己肯定也是字符串常量，所以s2也同样在编译期就被解析为一个字符串常量，所以s2也是常量池中” kvill”的一个引用。所以我们得出s0==s1==s2；用new String() 创建的字符串不是常量，不能在编译期就确定，所以new String() 创建的字符串不放入常量池中，它们有自己的地址空间。
示例：
String s0="kvill"; String s1=new String("kvill"); String s2="kv" + new String("ill"); System.out.println( s0==s1 ); System.out.println( s0==s2 ); System.out.println( s1==s2 ); 结果为：
false
false
false
例2中s0还是常量池 中"kvill”的应用，s1因为无法在编译期确定，所以是运行时创建的新对象”kvill”的引用，s2因为有后半部分 new String(”ill”)所以也无法在编译期确定，所以也是一个新创建对象”kvill”的应用;明白了这些也就知道为何得出此结果了。
4. String.intern()：
再补充介绍一点：存在于.class文件中的常量池，在运行期被JVM装载，并且可以扩充。String的 intern()方法就是扩充常量池的 一个方法；当一个String实例str调用intern()方法时，Java 查找常量池中 是否有相同Unicode的字符串常量，如果有，则返回其的引用，如果没有，则在常 量池中增加一个Unicode等于str的字符串并返回它的引用；看示例就清楚了
示例：
String s0= "kvill"; String s1=new String("kvill"); String s2=new String("kvill"); System.out.println( s0==s1 ); System.out.println( "**********" ); s1.intern(); s2=s2.intern(); //把常量池中"kvill"的引用赋给s2 System.out.println( s0==s1); System.out.println( s0==s1.intern() ); System.out.println( s0==s2 ); 结果为：
false
false //虽然执行了s1.intern(),但它的返回值没有赋给s1
true //说明s1.intern()返回的是常量池中"kvill"的引用
true
最后我再破除一个错误的理解：有人说，“使用 String.intern() 方法则可以将一个 String 类的保存到一个全局 String 表中 ，如果具有相同值的 Unicode 字符串已经在这个表中，那么该方法返回表中已有字符串的地址，如果在表中没有相同值的字符串，则将自己的地址注册到表中”如果我把他说的这个全局的 String 表理解为常量池的话，他的最后一句话，”如果在表中没有相同值的字符串，则将自己的地址注册到表中”是错的：
示例：
String s1=new String("kvill"); String s2=s1.intern(); System.out.println( s1==s1.intern() ); System.out.println( s1+" "+s2 ); System.out.println( s2==s1.intern() ); 结果：
false
kvill kvill
true
在这个类中我们没有声名一个”kvill”常量，所以常量池中一开始是没有”kvill”的，当我们调用s1.intern()后就在常量池中新添加了一 个”kvill”常量，原来的不在常量池中的”kvill”仍然存在，也就不是“将自己的地址注册到常量池中”了。
s1==s1.intern() 为false说明原来的”kvill”仍然存在；s2现在为常量池中”kvill”的地址，所以有s2==s1.intern()为true。
5. 关于equals()和==:
这个对于String简单来说就是比较两字符串的Unicode序列是否相当，如果相等返回true;而==是 比较两字符串的地址是否相同，也就是是否是同一个字符串的引用。
6. 关于String是不可变的
这一说又要说很多，大家只 要知道String的实例一旦生成就不会再改变了，比如说：String str=”kv”+”ill”+” “+”ans”; 就是有4个字符串常量，首先”kv”和”ill”生成了”kvill”存在内存中，然后”kvill”又和” ” 生成 “kvill “存在内存中，最后又和生成了”kvill ans”;并把这个字符串的地址赋给了str,就是因为String的”不可变”产生了很多临时变量，这也就是为什么建议用StringBuffer的原 因了，因为StringBuffer是可改变的。
下面是一些String相关的常见问题：
String中的final用法和理解
final StringBuffer a = new StringBuffer("111");
final StringBuffer b = new StringBuffer("222");
a=b;//此句编译不通过
final StringBuffer a = new StringBuffer("111");
a.append("222");// 编译通过
可见，final只对引用的"值"(即内存地址)有效，它迫使引用只能指向初始指向的那个对象，改变它的指向会导致编译期错误。至于它所指向的对象 的变化，final是不负责的。
String常量池问题的几个例子
下面是几个常见例子的比较分析和理解：
String a = "a1"; String b = "a" + 1; System.out.println((a == b)); //result = true String a = "atrue"; String b = "a" + "true"; System.out.println((a == b)); //result = true String a = "a3.4"; String b = "a" + 3.4; System.out.println((a == b)); //result = true 分析：JVM对于字符串常量的"+"号连接，将程序编译期，JVM就将常量字符串的"+"连接优化为连接后的值，拿"a" + 1来说，经编译器优化后在class中就已经是a1。在编译期其字符串常量的值就确定下来，故上面程序最终的结果都为true。
String a = "ab"; String bb = "b"; String b = "a" + bb; System.out.println((a == b)); //result = false 分析：JVM对于字符串引用，由于在字符串的"+"连接中，有字符串引用存在，而引用的值在程序编译期是无法确定的，即"a" + bb无法被编译器优化，只有在程序运行期来动态分配并将连接后的新地址赋给b。所以上面程序的结果也就为false。
String a = "ab"; final String bb = "b"; String b = "a" + bb; System.out.println((a == b)); //result = true 分析：和[3]中唯一不同的是bb字符串加了final修饰，对于final修饰的变量，它在编译时被解析为常量值的一个本地拷贝存储到自己的常量 池中或嵌入到它的字节码流中。所以此时的"a" + bb和"a" + "b"效果是一样的。故上面程序的结果为true。
String a = "ab"; final String bb = getBB(); String b = "a" + bb; System.out.println((a == b)); //result = false private static String getBB() { return "b"; } 分析：JVM对于字符串引用bb，它的值在编译期无法确定，只有在程序运行期调用方法后，将方法的返回值和"a"来动态连接并分配地址为b，故上面 程序的结果为false。
通过上面4个例子可以得出得知：
String s = "a" + "b" + "c";
就等价于String s = "abc";
String a = "a";
String b = "b";
String c = "c";
String s = a + b + c;
这个就不一样了，最终结果等于：
StringBuffer temp = new StringBuffer(); temp.append(a).append(b).append(c); String s = temp.toString(); 由上面的分析结果，可就不难推断出String 采用连接运算符（+）效率低下原因分析，形如这样的代码：
public class Test { public static void main(String args[]) { String s = null; for(int i = 0; i
100; i++) { s += "a"; } } } 每做一次 + 就产生个StringBuilder对象，然后append后就扔掉。下次循环再到达时重新产生个StringBuilder对象，然后 append 字符串，如此循环直至结束。如果我们直接采用 StringBuilder 对象进行 append 的话，我们可以节省 N - 1 次创建和销毁对象的时间。所以对于在循环中要进行字符串连接的应用，一般都是用StringBuffer或StringBulider对象来进行 append操作。
String对象的intern方法理解和分析：
public class Test4 { private static String a = "ab"; public static void main(String[] args){ String s1 = "a"; String s2 = "b"; String s = s1 + s2; System.out.println(s == a);//false System.out.println(s.intern() == a);//true } } 这里用到Java里面是一个常量池的问题。对于s1+s2操作，其实是在堆里面重新创建了一个新的对象,s保存的是这个新对象在堆空间的的内容，所 以s与a的值是不相等的。而当调用s.intern()方法，却可以返回s在常量池中的地址值，因为a的值存储在常量池中，故s.intern和a的值相等。
总结
栈中用来存放一些原始数据类型的局部变量数据和对象的引用(String,数组.对象等等)但不存放对象内容
堆中存放使用new关键字创建的对象.
字符串是一个特殊包装类,其引用是存放在栈里的,而对象内容必须根据创建方式不同定(常量池和堆).有的是编译期就已经创建好，存放在字符串常 量池中，而有的是运行时才被创建.使用new关键字，存放在堆中。