java笔记之java内存结构
前言
1.每一个方法执行时，都有一个独立的内存空间，给内存空间在方法执行完毕之后，随之被回收。这个入地的内存空间称之为栈帧。
2.堆存放的是当前java程序执行时共享数据。在堆中，如果一个对象没有被变量指向，该变量就符合垃圾回收机制的条件。
正文
简单的java内存结构图
1.方法区：用来存储代码。将.class文件加载到内存中，并存储在方法区
2.栈：用来存储局部变量，形参，方法的返回值，中间运算结果
3.堆：成员变量，数组对象，方法的引用
4.本地方法区：存储链接本地方法相关的代码
5.执行过程：
执行了java命令之后，classloader将.class文件，加载到内存中并存储在方法区。
然后JVM调用main方法，顺次执行代码。
将局部变量存储在栈区中，将引用变量是指向内容存储在堆区中。
引用变量所指向的空间，用来存储hashcode码，顺次执行到mian方法完毕。
再通过classLoader将.class文件内容在JVM所占用的空间全部卸载。
程序运行时保存到什么地方
(1) 寄存器。这是最快的保存区域，因为它位于处理器内部。然而，寄存器的数量十分有限，所以寄存器是根据需要由编译器分配。
(2) 堆栈。驻留于常规RAM（随机访问存储器）区域，但可通过它的“堆栈指针”获得处理的直接支持。堆栈指针若向下移，会创建新的内存；若向上移，则会释放那些内存。这是一种特别快、特别有效的数据保存方式，仅次于寄存器。创建程序时，Java编译器必须准确地知道堆栈内保存的所有数据的“长度”以及“存在时间”。这是由于它必须生成相应的代码，以便向上和向下移动指针。这一限制无疑影响了程序的灵活性，所以尽管有些Java数据要保存在堆栈里——特别是对象句柄，但Java对象并不放到其中。
(3) 堆。一种常规用途的内存池（也在RAM区域），其中保存了Java对象。和堆栈不同，“内存堆”或“堆”（Heap）最吸引人的地方在于编译器不必知道要从堆里分配多少存储空间，也不必知道存储的数据要在堆里停留多长的时间。因此，用堆保存数据时会得到更大的灵活性。要求创建一个对象时，只需用new命令编制相关的代码即可。执行这些代码时，会在堆里自动进行数据的保存。当然，为达到这种灵活性，必然会付出一定的代价：在堆里分配存储空间时会花掉更长的时间！
(4) 静态存储。这儿的“静态”（Static）是指“位于固定位置”（尽管也在RAM里）。程序运行期间，静态存储的数据将随时等候调用。可用static关键字指出一个对象的特定元素是静态的。但Java对象本身永远都不会置入静态存储空间。
(5) 常数存储。常数值通常直接置于程序代码内部。这样做是安全的，因为它们永远都不会改变。有的常数需要严格地保护，所以可考虑将它们置入只读存储器（ROM）。
(6) 非RAM存储。若数据完全独立于一个程序之外，则程序不运行时仍可存在，并在程序的控制范围之外。其中两个最主要的例子便是“流式对象”和“固定对象”。对于流式对象，对象会变成字节流，通常会发给另一台机器。而对于固定对象，对象保存在磁盘中。即使程序中止运行，它们仍可保持自己的状态不变。对于这些类型的数据存储，一个特别有用的技巧就是它们能存在于其他媒体中。一旦需要，甚至能将它们恢复成普通的、基于RAM的对象。Java 1.1提供了对Lightweight
persistence的支持。未来的版本甚至可能提供更完整的方案。
深入Java虚拟机JVM类加载初始化学习
1. Classloader的作用，就是将编译后的class装载、加载到机器内存中，为了以后的程序的执行提供前提条件。
2. 一段程序引发的思考：
诡异代码如下：
| package test01;
class Singleton {
publicstatic Singletonsingleton =new Singleton(); publicstaticinta; publicstaticintb = 0;
private Singleton() { super(); a++; b++; }
publicstatic SingletonGetInstence() { returnsingleton; }
}
publicclass MyTest {
/** * @param args */ publicstaticvoid main(String[] args) { Singleton mysingleton = Singleton.GetInstence(); System.out.println(mysingleton.a); System.out.println(mysingleton.b); }
} |
一般不假思索的结论就是，a=1,b=1。给出的原因是：a、b都是静态变量，在构造函数调用的时候已经对a和b都加1了。答案就都是1。但是运行完后答案却是a=1,b=0。
下面我们将代码稍微变一下
| publicstatic Singletonsingleton =new Singleton(); publicstaticinta; publicstaticintb = 0; |
的代码部分替换成
| publicstaticinta; publicstaticintb = 0; publicstatic Singletonsingleton =new Singleton(); |
效果就是刚才预期的a=1,b=1。
为什么呢，这3句无非就是静态变量的声明、初始化，值的变化和声明的顺序还有关系吗？Java不是面向对象的吗？怎么和结构化的语言似地，顺序还有关系。这个就是和Java虚拟机JVM加载类的原理有着直接的关系。
3. 类在JVM中的工作原理
要想使用一个Java类为自己工作，必须经过以下几个过程
1）：类加载load：从字节码二进制文件——.class文件将类加载到内存，从而达到类的从硬盘上到内存上的一个迁移，所有的程序必须加载到内存才能工作。将内存中的class放到运行时数据区的方法区内，之后在堆区建立一个java.lang.Class对象，用来封装方法区的数据结构。类加载的最终产物就是堆中的一个java.lang.Class对象。
2）：连接：连接又分为以下小步骤
a.验证：出于安全性的考虑，验证内存中的字节码是否符合JVM的规范，类的结构规范、语义检查、字节码操作是否合法、这个是为了防止用户自己建立一个非法的XX.class文件就进行工作了，或者是JVM版本冲突的问题，比如在JDK6下面编译通过的class（其中包含注解特性的类），是不能在JDK1.4的JVM下运行的。
b.准备：将类的静态变量进行分配内存空间、初始化默认值。（对象还没生成呢，所以这个时候没有实例变量什么事情）
c.解析：把类的符号引用转为直接引用（保留）
3）：类的初始化：将类的静态变量赋予正确的初始值，这个初始值是开发者自己定义时赋予的初始值，而不是默认值。
4. 类的主动使用与被动使用
以下是视为主动使用一个类，其他情况均视为被动使用！
1）：初学者最为常用的new一个类的实例对象（声明不叫主动使用）
2）：对类的静态变量进行读取、赋值操作的。
3）：直接调用类的静态方法。
4）：反射调用一个类的方法。
5）：初始化一个类的子类的时候，父类也相当于被程序主动调用了（如果调用子类的静态变量是从父类继承过来并没有复写的，那么也就相当于只用到了父类的东东，和子类无关，所以这个时候子类不需要进行类初始化）。
6）：直接运行一个main函数入口的类。
所有的JVM实现（不同的厂商有不同的实现，有人就说IBM的实现比Sun的要好……）在首次主动调用类和接口的时候才会初始化他们。
5. 类的加载方式
1）：本地编译好的class中直接加载
2）：网络加载：java.net.URLClassLoader可以加载url指定的类
3）：从jar、zip等等压缩文件加载类，自动解析jar文件找到class文件去加载util类
4）：从java源代码文件动态编译成为class文件
6. 类加载器
JVM自带的默认加载器
1）：根类加载器：bootstrap，由C++编写，所有Java程序无法获得。
2）：扩展类加载器：由Java编写。
3）：系统类、应用类加载器：由Java编写。
用户自定义的类加载器：java.lang.ClassLoader的子类，用户可以定制类的加载方式。每一个类都包含了加载他的ClassLoader的一个引用——getClass().getClassLoader()。如果返回的是null，证明加载他的ClassLoader是根加载器bootstrap。
如下代码
| publicstaticvoid main(String[] args)throws ClassNotFoundException { Class clazz = Class.forName("java.lang.String"); System.out.println(clazz.getClassLoader()); } |
结果是null，证明java.lang.String是根类加载器去加载的。
| publicstaticvoid main(String[] args) { Singleton mysingleton = Singleton.GetInstence(); System.out.println(mysingleton.getClass().getClassLoader()); } |
结果是sun.misc.Launcher$AppClassLoader@19821f，证明是AppClassLoader（系统类、应用类加载器）去加载的。像jre的rt.jar下面的java.lang.*都是默认的根类加载器去加载这些运行时的类。
7. 解释类连接阶段的准备
类的如下代码片段
| publicstaticinta; publicstaticintb = 10; |
在这个阶段，加载器会按照结构化似的，从上到下流程将静态变量int类型分配4个字节的空间，并且为其赋予默认值0，而像b = 10这段代码在此阶段是不起作用的，b仍然是默认值0。
8. 解释类连接阶段的解析
这里面的指针就是C++的指针
9. 回顾那个诡异的代码
从入口开始看
| Singleton mysingleton = Singleton.GetInstence(); |
是根据内部类的静态方法要一个Singleton实例。
这个时候就属于主动调用Singleton类了。
之后内存开始加载Singleton类
1）：对Singleton的所有的静态变量分配空间，赋默认的值，所以在这个时候，singleton=null、a=0、b=0。注意b的0是默认值，并不是咱们手工为其赋予的的那个0值。
2）：之后对静态变量赋值，这个时候的赋值就是我们在程序里手工初始化的那个值了。此时singleton = new Singleton();调用了构造方法。构造方法里面a=1、b=1。之后接着顺序往下执行。
3）：
| publicstaticinta; publicstaticintb = 0; |
a没有赋值，保持原状a=1。b被赋值了，b原先的1值被覆盖了，b=0。所以结果就是这么来的。类中的静态块static块也是顺序地从上到下执行的。
10. 编译时常量、非编译时常量的静态变量
如下代码
| package test01;
class FinalStatic {
publicstaticfinalintA = 4 + 4;
static { System.out.println("如果执行了，证明类初始化了……"); }
}
publicclass MyTest03 {
/** * @param args */ publicstaticvoid main(String[] args) { System.out.println(FinalStatic.A); }
} |
结果是只打印出了8，证明类并没有初始化。反编译源码发现class里面的内容是
| public static final int A = 8; |
也就是说编译器很智能的、在编译的时候自己就能算出4+4是8，是一个固定的数字。没有什么未知的因素在里面。
将代码稍微改一下
| public static final int A = 4 + new Random().nextInt(10); |
这个时候静态块就执行了，证明类初始化了。在静态final变量在编译时不定的情况下。如果客户程序这个时候访问了该类的静态变量，那就会对类进行初始化，所以尽量静态final变量尽量没什么可变因素在里面1，否则性能会有所下降。
11. ClassLoader的剖析
ClassLoader的loadClass方法加载一个类不属于主动调用，不会导致类的初始化。如下代码块
| ClassLoader classLoader = ClassLoader.getSystemClassLoader(); Class<?> clazz = classLoader.loadClass("test01.ClassDemo"); |
并不会让类加载器初始化test01.ClassDemo，因为这不属于主动调用此类。
ClassLoader的关系：
根加载器——》扩展类加载器——》应用类加载器——》用户自定义类加载器
加载类的过程是首先从根加载器开始加载、根加载器加载不了的，由扩展类加载器加载，再加载不了的有应用加载器加载，应用加载器如果还加载不了就由自定义的加载器（一定继承自java.lang. ClassLoader）加载、如果自定义的加载器还加载不了。而且下面已经没有再特殊的类加载器了，就会抛出ClassNotFoundException，表面上异常是类找不到，实际上是class加载失败，更不能创建该类的Class对象。
若一个类能在某一层类加载器成功加载，那么这一层的加载器称为定义类加载器。那么在这层类生成的Class引用返回下一层加载器叫做初始类加载器。因为加载成功后返回"一个Class引用"给它的服务对象——(也就是调用它的类加载器)。考虑到安全，父委托加载机制。
ClassLoader加载类的原代码如下
| protectedsynchronized Class<?>loadClass(String name, boolean resolve) throws ClassNotFoundException { // First, check if the class has already been loaded Class c = findLoadedClass(name); if (c ==null) { try { if (parent !=null) { c = parent.loadClass(name,false); } else { c = findBootstrapClassOrNull(name); } } catch (ClassNotFoundException e) { // ClassNotFoundException thrown if class not found // from the non-null parent class loader } if (c ==null) { // If still not found, then invoke findClass in order // to find the class. c = findClass(name); } } if (resolve) { resolveClass(c); } return c; } |
初始化系统ClassLoader代码如下
| privatestaticsynchronizedvoid initSystemClassLoader() { if (!sclSet) { if (scl !=null) thrownew IllegalStateException("recursive invocation"); sun.misc.Launcher l = sun.misc.Launcher.getLauncher(); if (l !=null) { Throwable oops = null; scl = l.getClassLoader(); try { PrivilegedExceptionAction a; a = new SystemClassLoaderAction(scl); scl = (ClassLoader) AccessController.doPrivileged(a); } catch (PrivilegedActionException pae) { oops = pae.getCause(); if (oopsinstanceof InvocationTargetException) { oops = oops.getCause(); } } if (oops !=null) { if (oopsinstanceof Error) { throw (Error) oops; } else { // wrap the exception thrownew Error(oops); } } } sclSet = true; } } |
它里面调用了很多native的方法，也就是通过JNI调用底层C++的代码。
12. 当一个类被加载、连接、初始化后，它的生命周期就开始了，当代表该类的Class对象不再被引用、即已经不可触及的时候，Class对象的生命周期结束。那么该类的方法区内的数据也会被卸载，从而结束该类的生命周期。一个类的生命周期取决于它Class对象的生命周期。由Java虚拟机自带的默认加载器（根加载器、扩展加载器、系统加载器）所加载的类在JVM生命周期中始终不被卸载。所以这些类的Class对象（我称其为实例的模板对象）始终能被触及！而由用户自定义的类加载器所加载的类会被卸载掉！
JVM简单理解
1 Java栈
Java栈是与每一个线程关联的，JVM在创建每一个线程的时候，会分配一定的栈空间给线程。它主要用来存储线程执行过程中的局部变量，方法的返回值，以及方法调用上下文。栈空间随着线程的终止而释放。
StackOverflowError：如果在线程执行的过程中，栈空间不够用，那么JVM就会抛出此异常，这种情况一般是死递归造成的。
2 堆
Java中堆是由所有的线程共享的一块内存区域，堆用来保存各种JAVA对象，比如数组，线程对象等。
JVM堆一般又可以分为以下三部分：
Perm
Perm代主要保存class,method,filed对象，这部门的空间一般不会溢出，除非一次性加载了很多的类，不过在涉及到热部署的应用服务器的时候，有时候会遇到java.lang.OutOfMemoryError : PermGen space 的错误，造成这个错误的很大原因就有可能是每次都重新部署，但是重新部署后，类的class没有被卸载掉，这样就造成了大量的class对象保存在了perm中，这种情况下，一般重新启动应用服务器可以解决问题。
Tenured
Tenured区主要保存生命周期长的对象，一般是一些老的对象，当一些对象在Young复制转移一定的次数以后，对象就会被转移到Tenured区，一般如果系统中用了application级别的缓存，缓存中的对象往往会被转移到这一区间。
Young
Young区被划分为三部分，Eden区和两个大小严格相同的Survivor区，其中Survivor区间中，某一时刻只有其中一个是被使用的，另外一个留做垃圾收集时复制对象用，在Young区间变满的时候，minor GC就会将存活的对象移到空闲的Survivor区间中，根据JVM的策略，在经过几次垃圾收集后，任然存活于Survivor的对象将被移动到Tenured区间。