浅析Java内存分配

线程共享区域：方法区，堆
线程私有区域：程序计数器，本地方法栈，虚拟机栈

内存.png

虚拟机栈

线程私有，生命周期与线程一致。每调用一个方法就可以创建一个新的栈帧，栈帧中存放局部变量表（基本类型数据和对象引用）、操作数栈和方法出口等信息。大小可动态扩展。
在编译期间分配内存
当栈调用深度大于JVM所允许的范围，会抛出StackOverflowError的错误；当申请不到空间时，会抛出 OutOfMemoryError。

本地方法栈

空间较小，用于获取要执行的字节码指令。

PC 寄存器：

也叫程序计数器。JVM支持多个线程同时运行，每个线程都有自己的程序计数器。倘若当前执行的是 JVM 的方法，则该寄存器中保存当前执行指令的地址；倘若执行的是native 方法，则PC寄存器中为空。

堆

虚拟机中内存最大的一块，在虚拟机启动时创建，用于存储方法实例。可以划分出多个线程私有的缓冲区，可以处于物理上不连续，逻辑上连续的空间中。
常量池位于堆中。JVM为每个已加载的类型维护一个常量池。存储直接常量（基本类型 、String）和对其他类型方法、字段的符号引用。在Java动态链接中起核心作用。

方法区

主要用于存储类的信息、常量池、方法数据、方法代码等。方法区逻辑上属于堆的一部分，但是为了与堆进行区分，通常又叫“非堆”。

小结：

1 实例位于栈中，对象在堆中。操作实例，实际上是通过实例的指针间接操作对象。
2 栈中的数据和堆中的数据销毁不同步。
方法一但结束，栈中的局部变量立即销毁，然鹅可能还有其他变量指向堆中的对象，知道栈中没有任何对象指向它，在垃圾回收时，才能被销毁。
3 每个JVM实例都有自己的内存区域，且互不影响。（这些内存区域都是线程共享的）
4 类的成员变量在不同的对象中个不相同，存储在堆中的对象里。而方法这是使用时才压入栈中。

---

普通Java对象的创建过程

虚拟机在遇到new指令时，

• 检查该指令参数是否可以在常量池中定位到一个类的符号引用，并检查它是否被加载、解析或者初始化过，如果没有字执行类加载。
• 为新生对象分配内存，即将一块确定大小的内存从Java堆中划分出来（在类加载时确定其大小）
  >指针碰撞： Java堆中的内存绝对规整，用过的在一边，未用的在另一边，中间放置一个指针作为指示器。分配内存即将指针移向所用空间的距离。
  >空闲列表：Java堆中的内存并不规整，虚拟机维护一个列表类似记录哪块内存是用过的哪块是没有的，分配时从中找到一个足够大的区域划分给对象，并且更新列表。
• 解决并发产生的问题
  >在分配内存空间时做同步处理，即采用CAS和失败重试的方式保证更新时，操作的原子性。
  >将该动作划分在不同的空间中进行。
• 将分配的内存空间初始化为0
• 对对象进行必要设置（此时，虚拟机看来，对象已经产生，但是对于程序而言，还没有产生）
• 执行()

---

类加载的过程

案例分析：

class Singleton{
  private static Singleton singleton=new Singleton();
  public static int count_1;//1
  public static int count_2=0;//0
  static{
     count_1++;
      count_2++;
  }
  private Singleton(){
    count_1++://1
    count_2++;//1
  }
  public static Singleton getInstance(){
    return singleton;
  }
}
public class ClassLoaderProcess{
  public static void main(String[] args){
    System,out.println(count_1);//2
    System,out.println(count_2);//1
  }
}

• 准备阶段：private Singleton()方法将count_1和count_2赋为零值
• 初始化阶段：Java虚拟机按顺序执行
  >实例化private Singleton()方法，count_1++;//1、 count_2++;//1
  >按顺序执行static代码，静态变量的值赋为代码中的初始化值：count_1;//1、count_2=0;
  >执行静态代码块中的代码，即自增，count_1=2;、count_2=1;

具体内容可以看下面的链接，详细的不能再详细的那种

http://blog.csdn.net/u013256816/article/details/50829596

Java虚拟机类加载机制——案例分析

http://www.importnew.com/18566.html

---

内存溢出

• Java堆内存溢出

public class HeapOOM{
  static class OOMObject{}
  public static void main(String[] args){
    List list=new ArrayList();
    while(true){
      list.add(new OOMObject);
    }
  }  
}

Java堆用来存储对象实例，只要不断的创建对象，并且保证GCRoots到对象之间都有可达路径来避免垃圾回收机制来清楚这些对象，就会造成OOM

• 虚拟机栈和本地方法栈溢出

如果线程请求的栈深度大于虚拟机所允许的最大深度，将抛出StackOverFlowError；
减少栈内存容量或者定义大量的本地变量(导致栈帧变大)会导致以上错误

public class JavaVMStackSOF{
  private int stackLength=1;
  public void stackLeak(){
    stackLength++；
    stackLeak();
  }
  public static void main(String[] args){
    JavaVMStackSOF oom=new JavaVMStackSOF();
    try{
      oom.stackLeak();
  }  catch(Throwable e){
    System,out.println("stack length: "+oom.stackLength);
    throw e;
  }
}

如果虚拟机在扩展栈的时候，无法申请到足够的内存空间，则抛出OutOfMemoryError。
多线程中，每个线程分配的栈内存越大，越容易产生内存溢出。
解决方案：减少最大堆和减少栈容量来换取更多的线程。

public class JavaVMStackOOM{
  private void dontStop(){
    while(true){}
  }
  public void stackLeakByThread(){
    while(true){
      Thread thread=new Thread(new Runnable(){
          public void run(){
            dontStop();
          }
        }
        
    );
    thread.start();
    }
    stackLength++；
    stackLeak();
  }
  public static void main(String[] args){
    JavaVMStackOOM oom=new JavaVMStackOOM();
    oom.stackLeakByThread();
   }
}

• 方法区和运行时常量池溢出
• 本机直接内存溢出

---

内存泄露

• 只要类自己管理内存需要警惕内存泄露问题。
  一旦元素被释放掉，该元素中包含的任何引用都要被清空
  E.G.Stack类自己管理内存，存储池中包含了elements数组（对象引用单元而不是对象本身的元素）的元素，数组活动区域中的元素时已经分配好的，而数据其余部分的元素是自由的。但是垃圾回收器对他们一视同仁，即elements的所有元素都同等有效。

Solution:在数组元素变成非活动部分时，程序员手动清除这些元素

• 缓存也会造成内存泄露
  一旦对象进入缓存就很容易被遗忘

Solution_1:用WeakHashMap代表缓存。只要在缓存之外存在对某个对象的key的引用，该项就有意义。当缓存中的项过期后，他们会自动被删除。
当索要缓存的项的生命周期是由该键的外部引用决定，而不是缓存项的值决定时，WeakHashMap才有用

Solution_2:由后台线程定期清除或者在给缓存中添加新的条目的时候顺便清理。（LinkedHashMap利用其removeEldestEntry实现）

Solution_3:对于复杂内存，java.lang.ref解决

• 监听器与其他回调
  E.G.如果实现了一个api，客户端在改api调用中注册回调，却没有显示的取消，除非采取某些动作，否则他们会继续聚集。

Solution:保存其弱引用，即将他们作为WeakHashMap中的键即可。