A. Java构造函数（方法）存储在jvm哪个内存里
存放到方法区当中；
new出来的是实例对象，实例对象才是存放在堆当中；
构造函数对应的是<init>方法，方法信息随着类加载器加载到方法区当中。
栈：
以栈帧为单位，存放的不是方法具体的结构，只是通常一个方法对应一个栈帧，对应的入栈出栈就是栈帧的入栈出栈。栈帧中有局部变量表，操作数栈，方法返回地址，动态链接。其中局部变量表存放局部变量，包括形参，非静态方法默认在第一个索引存放一个this变量；操作数栈用于操作局部变量表和一些值的运算，比如读取表中变量的值进行运算，或存放相应的值到局部变量表中；方法返回地址则是用于记录对应方法的下一条指令的地址；动态链接是符号引用变成的直接引用。
堆：
存放实例对象，在jdk7开始，还存放静态变量和字符串常量池
方法区：
存放类元信息，比如完整类名全称，public,abstract等修饰符，实现的接口有序列表等；方法信息，比如修饰符，返回类型等；JIT代码缓存，也就是被即时编译器编译后的热点代码，用于提高性能；域信息，也就是属性信息，比如修饰符，类型等；运行时常量池，字节码文件中常量池的运行时表现，类似符号引用的记录，不过蕴含的信息更为丰富，而且具有动态性。jdk6及以前，还存放静态变量，运行时常量池中还存放字符串常量池，到了jdk7则移到了堆中。
B. 上次你回答了我 静态常量 和 常量的存储位置， 我想问一下，局部常量就是方法 中的常量 jvm是如何处理的
方法是由线程来执行的，每个线程都有一块属于自己的栈空间。也就是说线程创建的时候，这个栈空间也就创建了，线程销毁时这个栈也就销毁。这个栈的内存只有线程本身可以访问，称它为虚拟机栈，或者方法栈。
每当线程执行一个方法时，会在自己的方法栈中添加一个栈帧，你可以理解为放了一个东西进栈。方法结束时，这个栈帧就会出栈销毁。eclipse调试窗口形象的描述了这个栈，你可以看到随着方法的调用，栈帧会增多，方法执行完后栈帧就减少。当前正在执行的方法栈帧肯定是在栈的最顶部。
每一个栈帧都包含一个局部变量表用来存放局部变量，线程调用方法创建栈帧后，将this引用、方法的参数、局部变量，全部按顺序依次分配在这个栈帧的局部变量表中，显然，当方法结束后，栈帧出栈销毁，这些局部变量也就释放了。你在调试的时候，看到的variabel窗口中的变量，就是局部变量表中的变量，可以看到实例方法中this变量总是在最上面，然后方法的参数、方法中的局部变量依次排下来。
另外，方法中的局部变量并不叫常量，这个你要注意一下
C. 在Java JVM里，如果一个变量被声明为final或者static， 那么这个变量的引用以及它的值被存放在哪
static不能用在方法里面，只能修饰类的属性或者方法。
static修饰的变量被放在方法区，因为它属于类变量，是类的一部分。
所有的方法中的普通变量都是在栈中的局部变量表中的，如果是引用类型的变量局部变量表会存放引用对象的地址，这个引用对象实际存储在堆中。如果被final修饰的话代表这个引用类型的变量指向的地址无法被改变。所以final修饰的引用的地址和final修饰的基本数据类型都会放在常量池，常量池位于方法区中。
D. 哪位能描述一下 java 中内存的分区情况和各类变量在内存中的存贮情况。
Java内存分配与管理是Java的核心技术之一，一般Java在内存分配时会涉及到以下区域：
◆寄存器：我们在程序中无法控制
◆栈：存放基本类型的数据和对象的引用，但对象本身不存放在栈中，而是存放在堆中
◆堆：存放用new产生的数据
◆静态域：存放在对象中用static定义的静态成员
◆常量池：存放常量
◆非RAM存储：硬盘等永久存储空间
Java内存分配中的栈
在函数中定义的一些基本类型的变量数据和对象的引用变量都在函数的栈内存中分配。
当在一段代码块定义一个变量时，Java就在栈中为这个变量分配内存空间，当该变量退出该作用域后，Java会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。
Java内存分配中的堆
堆内存用来存放由new创建的对象和数组。在堆中分配的内存，由Java虚拟机的自动垃圾回收器来管理。
在堆中产生了一个数组或对象后，还可以在栈中定义一个特殊的变量，让栈中这个变量的取值等于数组或对象在堆内存中的首地址，栈中的这个变量就成了数组或对象的引用变量。引用变量就相当于是为数组或对象起的一个名称，以后就可以在程序中使用栈中的引用变量来访问堆中的数组或对象。引用变量就相当于是为数组或者对象起的一个名称。
引用变量是普通的变量，定义时在栈中分配，引用变量在程序运行到其作用域之外后被释放。而数组和对象本身在堆中分配，即使程序运行到使用new产生数组或者对象的语句所在的代码块之外，数组和对象本身占据的内存不会被释放，数组和对象在没有引用变量指向它的时候，才变为垃圾，不能在被使用，但仍然占据内存空间不放，在随后的一个不确定的时间被垃圾回收器收走（释放掉）。这也是Java比较占内存的原因。
实际上，栈中的变量指向堆内存中的变量，这就是Java中的指针！
常量池(constantpool)
常量池指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。除了包含代码中所定义的各种基本类型（如int、long等等）和对象型（如String及数组）的常量值(final)还包含一些以文本形式出现的符号引用，比如：
◆类和接口的全限定名；
◆字段的名称和描述符；
◆方法和名称和描述符。
虚拟机必须为每个被装载的类型维护一个常量池。常量池就是该类型所用到常量的一个有序集和，包括直接常量（string,integer和floatingpoint常量）和对其他类型，字段和方法的符号引用。
对于String常量，它的值是在常量池中的。而JVM中的常量池在内存当中是以表的形式存在的，对于String类型，有一张固定长度的CONSTANT_String_info表用来存储文字字符串值，注意：该表只存储文字字符串值，不存储符号引用。说到这里，对常量池中的字符串值的存储位置应该有一个比较明了的理解了。
在程序执行的时候,常量池会储存在MethodArea,而不是堆中。
堆与栈
Java的堆是一个运行时数据区,类的(对象从中分配空间。这些对象通过new、newarray、anewarray和multianewarray等指令建立，它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。
栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。栈中主要存放一些基本类型的变量数据（int,short,long,byte,float,double,boolean,char）和对象句柄(引用)。
栈有一个很重要的特殊性，就是存在栈中的数据可以共享。假设我们同时定义：
1. inta=3;
2. intb=3；
编译器先处理inta=3；首先它会在栈中创建一个变量为a的引用，然后查找栈中是否有3这个值，如果没找到，就将3存放进来，然后将a指向3。接着处理intb=3；在创建完b的引用变量后，因为在栈中已经有3这个值，便将b直接指向3。这样，就出现了a与b同时均指向3的情况。
这时，如果再令a=4；那么编译器会重新搜索栈中是否有4值，如果没有，则将4存放进来，并令a指向4；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。
要注意这种数据的共享与两个对象的引用同时指向一个对象的这种共享是不同的，因为这种情况a的修改并不会影响到b,它是由编译器完成的，它有利于节省空间。而一个对象引用变量修改了这个对象的内部状态，会影响到另一个对象引用变量。
String是一个特殊的包装类数据。可以用：
Stringstr=newString("abc");
Stringstr="abc";
两种的形式来创建，第一种是用new()来新建对象的，它会在存放于堆中。每调用一次就会创建一个新的对象。而第二种是先在栈中创建一个对String类的对象引用变量str，然后通过符号引用去字符串常量池里找有没有"abc",如果没有，则将"abc"存放进字符串常量池，并令str指向”abc”，如果已经有”abc”则直接令str指向“abc”。
比较类里面的数值是否相等时，用equals()方法；当测试两个包装类的引用是否指向同一个对象时，用==，下面用例子说明上面的理论。
1．Stringstr1="abc";
2．Stringstr2="abc";
3．System.out.println(str1==str2);//true
可以看出str1和str2是指向同一个对象的。
1．Stringstr1=newString("abc");
2．Stringstr2=newString("abc");
3．System.out.println(str1==str2);//false
用new的方式是生成不同的对象。每一次生成一个。
因此用第二种方式创建多个”abc”字符串,在内存中其实只存在一个对象而已.这种写法有利与节省内存空间.同时它可以在一定程度上提高程序的运行速度，因为JVM会自动根据栈中数据的实际情况来决定是否有必要创建新对象。而对于Stringstr=newString("abc")；的代码，则一概在堆中创建新对象，而不管其字符串值是否相等，是否有必要创建新对象，从而加重了程序的负担。
另一方面,要注意:我们在使用诸如Stringstr="abc"；的格式定义类时，总是想当然地认为，创建了String类的对象str。担心陷阱！对象可能并没有被创建！而可能只是指向一个先前已经创建的对象。只有通过new()方法才能保证每次都创建一个新的对象。
由于String类的immutable性质，当String变量需要经常变换其值时，应该考虑使用StringBuffer类，以提高程序效率。
1.首先String不属于8种基本数据类型，String是一个对象。因为对象的默认值是null，所以String的默认值也是null；但它又是一种特殊的对象，有其它对象没有的一些特性。
2.newString()和newString(”")都是申明一个新的空字符串，是空串不是null；
3.Stringstr=”kvill”；Stringstr=newString(”kvill”)的区别
示例：
1．Strings0="kvill";
2．Strings1="kvill";
3．Strings2="kv"+"ill";
4．System.out.println(s0==s1);
5．System.out.println(s0==s2);
结果为：
true
true
首先，我们要知结果为道Java会确保一个字符串常量只有一个拷贝。
因为例子中的s0和s1中的”kvill”都是字符串常量，它们在编译期就被确定了，所以s0==s1为true；而”kv”和”ill”也都是字符串常量，当一个字符串由多个字符串常量连接而成时，它自己肯定也是字符串常量，所以s2也同样在编译期就被解析为一个字符串常量，所以s2也是常量池中”kvill”的一个引用。所以我们得出s0==s1==s2；用newString()创建的字符串不是常量，不能在编译期就确定，所以newString()创建的字符串不放入常量池中，它们有自己的地址空间。
示例：
6．Strings0="kvill";
7．Strings1=newString("kvill");
8．Strings2="kv"+newString("ill");
9．System.out.println(s0==s1);
10．System.out.println(s0==s2);
11．System.out.println(s1==s2);
结果为：
false
false
false
例2中s0还是常量池中"kvill”的应用，s1因为无法在编译期确定，所以是运行时创建的新对象”kvill”的引用，s2因为有后半部分newString(”ill”)所以也无法在编译期确定，所以也是一个新创建对象”kvill”的应用;明白了这些也就知道为何得出此结果了。
4.String.intern()：
再补充介绍一点：存在于.class文件中的常量池，在运行期被JVM装载，并且可以扩充。String的intern()方法就是扩充常量池的一个方法；当一个String实例str调用intern()方法时，Java查找常量池中是否有相同Unicode的字符串常量，如果有，则返回其的引用，如果没有，则在常量池中增加一个Unicode等于str的字符串并返回它的引用；看示例就清楚了
示例：
1．Strings0="kvill";
2．Strings1=newString("kvill");
3．Strings2=newString("kvill");
4．System.out.println(s0==s1);
5．System.out.println("**********");
6．s1.intern();
7．s2=s2.intern();//把常量池中"kvill"的引用赋给s2
8．System.out.println(s0==s1);
9．System.out.println(s0==s1.intern());
10．System.out.println(s0==s2);
结果为：
false
false//虽然执行了s1.intern(),但它的返回值没有赋给s1
true//说明s1.intern()返回的是常量池中"kvill"的引用
true
最后我再破除一个错误的理解：有人说，“使用String.intern()方法则可以将一个String类的保存到一个全局String表中，如果具有相同值的Unicode字符串已经在这个表中，那么该方法返回表中已有字符串的地址，如果在表中没有相同值的字符串，则将自己的地址注册到表中”如果我把他说的这个全局的String表理解为常量池的话，他的最后一句话，”如果在表中没有相同值的字符串，则将自己的地址注册到表中”是错的：
示例：
1．Strings1=newString("kvill");
2．Strings2=s1.intern();
3．System.out.println(s1==s1.intern());
4．System.out.println(s1+""+s2);
5．System.out.println(s2==s1.intern());
结果：
1．false
2．kvillkvill
3．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的实例一旦生成就不会再改变了，比如说：Stringstr=”kv”+”ill”+”“+”ans”;就是有4个字符串常量，首先”kv”和”ill”生成了”kvill”存在内存中，然后”kvill”又和””生成“kvill“存在内存中，最后又和生成了”kvillans”;并把这个字符串的地址赋给了str,就是因为String的”不可变”产生了很多临时变量，这也就是为什么建议用StringBuffer的原因了，因为StringBuffer是可改变的。
下面是一些String相关的常见问题：
String中的final用法和理解
finalStringBuffera=newStringBuffer("111");
finalStringBufferb=newStringBuffer("222");
a=b;//此句编译不通过
finalStringBuffera=newStringBuffer("111");
a.append("222");//编译通过
可见，final只对引用的"值"(即内存地址)有效，它迫使引用只能指向初始指向的那个对象，改变它的指向会导致编译期错误。至于它所指向的对象的变化，final是不负责的。
String常量池问题的几个例子
下面是几个常见例子的比较分析和理解：
Stringa="a1";
Stringb="a"+1;
System.out.println((a==b));//result=true
Stringa="atrue";
Stringb="a"+"true";
System.out.println((a==b));//result=true
Stringa="a3.4";
Stringb="a"+3.4;
System.out.println((a==b));//result=true
分析：JVM对于字符串常量的"+"号连接，将程序编译期，JVM就将常量字符串的"+"连接优化为连接后的值，拿"a"+1来说，经编译器优化后在class中就已经是a1。在编译期其字符串常量的值就确定下来，故上面程序最终的结果都为true。
Stringa="ab";
Stringbb="b";
Stringb="a"+bb;
System.out.println((a==b));//result=false
分析：JVM对于字符串引用，由于在字符串的"+"连接中，有字符串引用存在，而引用的值在程序编译期是无法确定的，即"a"+bb无法被编译器优化，只有在程序运行期来动态分配并将连接后的新地址赋给b。所以上面程序的结果也就为false。
Stringa="ab";
finalStringbb="b";
Stringb="a"+bb;
System.out.println((a==b));//result=true
分析：和[3]中唯一不同的是bb字符串加了final修饰，对于final修饰的变量，它在编译时被解析为常量值的一个本地拷贝存储到自己的常量池中或嵌入到它的字节码流中。所以此时的"a"+bb和"a"+"b"效果是一样的。故上面程序的结果为true。
Stringa="ab";
finalStringbb=getBB();
Stringb="a"+bb;
System.out.println((a==b));//result=false
privatestaticStringgetBB(){
return"b";
}
分析：JVM对于字符串引用bb，它的值在编译期无法确定，只有在程序运行期调用方法后，将方法的返回值和"a"来动态连接并分配地址为b，故上面程序的结果为false。
通过上面4个例子可以得出得知：
Strings="a"+"b"+"c";
就等价于Strings="abc";
Stringa="a";
Stringb="b";
Stringc="c";
Strings=a+b+c;
这个就不一样了，最终结果等于：
1．StringBuffertemp=newStringBuffer();
2．temp.append(a).append(b).append(c);
3．Strings=temp.toString();
由上面的分析结果，可就不难推断出String采用连接运算符（+）效率低下原因分析，形如这样的代码：
publicclassTest{
publicstaticvoidmain(Stringargs[]){
Strings=null;
for(inti=0;i<100;i++){
s+="a";
}
}
}
每做一次+就产生个StringBuilder对象，然后append后就扔掉。下次循环再到达时重新产生个StringBuilder对象，然后append字符串，如此循环直至结束。如果我们直接采用StringBuilder对象进行append的话，我们可以节省N-1次创建和销毁对象的时间。所以对于在循环中要进行字符串连接的应用，一般都是用StringBuffer或StringBulider对象来进行append操作。
String对象的intern方法理解和分析：
1．publicclassTest4{
2．privatestaticStringa="ab";
3．publicstaticvoidmain(String[]args){
4．Strings1="a";
5．Strings2="b";
6．Strings=s1+s2;
7．System.out.println(s==a);//false
8．System.out.println(s.intern()==a);//true
9．}
10．}
这里用到Java里面是一个常量池的问题。对于s1+s2操作，其实是在堆里面重新创建了一个新的对象,s保存的是这个新对象在堆空间的的内容，所以s与a的值是不相等的。而当调用s.intern()方法，却可以返回s在常量池中的地址值，因为a的值存储在常量池中，故s.intern和a的值相等。
总结
栈中用来存放一些原始数据类型的局部变量数据和对象的引用(String,数组.对象等等)但不存放对象内容
堆中存放使用new关键字创建的对象.
字符串是一个特殊包装类,其引用是存放在栈里的,而对象内容必须根据创建方式不同定(常量池和堆).有的是编译期就已经创建好，存放在字符串常量池中，而有的是运行时才被创建.使用new关键字，存放在堆中。
E. Java中怎么知道一个变量的类型
复制下面代码：
class Test{
public static void main(String[] args){
int i=1; //int类型变量
System.out.println(getType(i)); //打印变量类型为int
}
public static String getType(Object o){ //获取变量类型方法
return o.getClass().toString(); //使用int类型的getClass()方法
}
}
(5)jvm怎么存储和识别变量类型扩展阅读：
java8种基本数据类型 (4种整型+2种浮点型+1种字符型+1种逻辑型)
4种整型：
byte-1 字节：-128~127 ；
short -2 字节：-32768~32767 ；
int-4 字节：-2^31~2^31-1；
long-8 字节：-2^63~2^63-11234。
2种浮点型
float-4 字节-32位IEEE 754单精度(有效位数6~7位)；
double-8 字节-64位IEEE 754双精度(有效位数15位)。
1种字符型
char-2 字节-整个Unicode字符集。
1种逻辑型
boolean-1 字节-true或者false。
F. java变量存储问题
我对你看到的这个东西很不认同啊，Java里对int类型是传值i的，你定义了两个不同的int类型变量a和b那么它们就是毫无关系的，应该是不同的两个地址才对。
凭我对编译原理的理解，我觉得Java和C什么的一样，对局部变量是这样处理的：
程序在编译的时候就会给变量分配其在栈中的位置。举个例子：
int a = 3; int b = 3;
int c = a + 1;
假设编译时给a分配的地址是“栈底+8”，b的地址是“栈底+12”，c的地址是“栈底+16”，那么这一段代码编译后变成：
mov 8(%ebp), 3
mov 12(%ebp), 3
add 16(%ebp), 8(%ebp), 1
也就是说编译之后，程序里就没有a、b这些东西了，直接通过地址来进行运算。
如果我上面的理解没有问题，那么对你的问题的回答是：
1）不用找。
2）不会改变，这个地址在编译时就分配好了。
3）我认为函数传参的时候对基本类型还是传值的，即会把基本类型的参数的值复制一份放到被调用函数的栈中；对于类变量才是直接扔进去一个地址。不过我不是很确定。
后补充的那一问，没错我同意你的看法。
G. jvm元空间存哪些数据
方法区也称为元空间，主要存放以下数据：
常量
静态变量：静态变量若为对象时，则存放对象在堆中的地址
类信息
H. 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