java内存结构

一、Java内存分配

1、 Java有几种存储区域？

* 寄存器

-- 在CPU内部，开发人员不能通过代码来控制寄存器的分配，由编译器来管理

* 栈

-- 在Windows下, 栈是向低地址扩展的数据结构，是一块连续的内存的区域，即栈顶的地址和栈的最大容量是系统预先规定好的。

-- 优点：由系统自动分配，速度较快。

-- 缺点：不够灵活，但程序员是无法控制的。

-- 存放基本数据类型、开发过程中就创建的对象(而不是运行过程中)

* 堆

-- 是向高地址扩展的数据结构，是不连续的内存区域

-- 在堆中，没有堆栈指针，为此也就无法直接从处理器那边获得支持

-- 堆的好处是有很大的灵活性。如Java编译器不需要知道从堆里需要分配多少存储区域，也不必知道存储的数据在堆里会存活多长时间。

* 静态存储区域与常量存储区域

-- 静态存储区用来存放static类型的变量

-- 常量存储区用来存放常量类型(final)类型的值，一般在只读存储器中

* 非RAM存储

-- 如流对象，是要发送到另外一台机器上的

-- 持久化的对象，存放在磁盘上

2、 java内存分配

-- 基础数据类型直接在栈空间分配;

-- 方法的形式参数，直接在栈空间分配，当方法调用完成后从栈空间回收;

-- 引用数据类型，需要用new来创建，既在栈空间分配一个地址空间，又在堆空间分配对象的类变量;

-- 方法的引用参数，在栈空间分配一个地址空间，并指向堆空间的对象区，当方法调用完后从栈空间回收;

-- 局部变量 new 出来时，在栈空间和堆空间中分配空间，当局部变量生命周期结束后，栈空间立刻被回收，堆空间区域等待GC回收;

-- 方法调用时传入的 literal 参数，先在栈空间分配，在方法调用完成后从栈空间释放;

-- 字符串常量在 DATA 区域分配 ，this 在堆空间分配;

-- 数组既在栈空间分配数组名称， 又在堆空间分配数组实际的大小！

3、Java内存模型

* Java虚拟机将其管辖的内存大致分三个逻辑部分：方法区(Method Area)、Java栈和Java堆。

-- 方法区是静态分配的，编译器将变量在绑定在某个存储位置上，而且这些绑定不会在运行时改变。

常数池，源代码中的命名常量、String常量和static 变量保存在方法区。

-- Java Stack是一个逻辑概念，特点是后进先出。一个栈的空间可能是连续的，也可能是不连续的。

最典型的Stack应用是方法的调用，Java虚拟机每调用一次方法就创建一个方法帧（frame），退出该方法则对应的 方法帧被弹出(pop)。栈中存储的数据也是运行时确定的？

-- Java堆分配(heap allocation)意味着以随意的顺序，在运行时进行存储空间分配和收回的内存管理模型。

堆中存储的数据常常是大小、数量和生命期在编译时无法确定的。Java对象的内存总是在heap中分配。

4、Java内存分配实例解析

常量池(constant pool)指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。它包括了关于类、方法、接口等中的常量，也包括字符串常量。

常量池在运行期被JVM装载，并且可以扩充。String的intern()方法就是扩充常量池的一个方法；当一个String实例str调用intern()方法时，Java查找常量池中是否有相同Unicode的字符串常量，如果有，则返回其引用，如果没有，则在常量池中增加一个Unicode等于str的字符串并返回它的引用。

例：

String s1=new String("kvill");

String s2=s1.intern();

System.out.println( s1==s1.intern() );//false

System.out.println( s1+" "+s2 );// kvill kvill

System.out.println( s2==s1.intern() );//true

这个类中事先没有声名”kvill”常量，所以常量池中一开始是没有”kvill”的，当调用s1.intern()后就在常量池中新添加了一个”kvill”常量，原来的不在常量池中的”kvill”仍然存在。s1==s1.intern()为false说明原来的“kvill”仍然存在；s2现在为常量池中“kvill”的地址，所以有s2==s1.intern()为true。

String 常量池问题

(1) 字符串常量的"+"号连接，在编译期字符串常量的值就确定下来, 拿"a" + 1来说，编译器优化后在class中就已经是a1。

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

(2) 对于含有字符串引用的"+"连接，无法被编译器优化。

String a = "ab";

String bb = "b";

String b = "a" + bb;

System.out.println((a == b)); //result = false

由于引用的值在程序编译期是无法确定的，即"a" + bb，只有在运行期来动态分配并将连接后的新地址赋给b。

(3) 对于final修饰的变量，它在编译时被解析为常量值的一个本地拷贝并存储到自己的常量池中或嵌入到它的字节码流中。所以此时的"a" + bb和"a" + "b"效果是一样的。

String a = "ab";

final String bb = "b";

String b = "a" + bb;

System.out.println((a == b)); //result = true

(4) jvm对于字符串引用bb，它的值在编译期无法确定，只有在程序运行期调用方法后，将方法的返回值和"a"来动态连接并分配地址为b。

String a = "ab";

final String bb = getbb();

String b = "a" + bb;

System.out.println((a == b)); //result = false

private static string getbb() {

return "b";

}

(5) String 变量采用连接运算符（+）效率低下。

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();

(6) Integer、Double等包装类和String有着同样的特性：不变类。

String str = "abc"的内部工作机制很有代表性，以Boolean为例，说明同样的问题。

不变类的属性一般定义为final，一旦构造完毕就不能再改变了。

Boolean对象只有有限的两种状态：true和false，将这两个Boolean对象定义为命名常量：

public static final Boolean TRUE = new Boolean(true);

public static final Boolean FALSE = new Boolean(false);

这两个命名常量和字符串常量一样，在常数池中分配空间。 Boolean.TRUE是一个引用，Boolean.FALSE是一个引用，而"abc"也是一个引用！由于Boolean.TRUE是类变量（static）将静态地分配内存，所以需要很多Boolean对象时，并不需要用new表达式创建各个实例，完全可以共享这两个静态变量。其JDK中源代码是：

public static Boolean valueOf(boolean b) {

return (b ? TRUE : FALSE);

}

基本数据(Primitive)类型的自动装箱(autoboxing)、拆箱(unboxing)是JSE 5.0提供的新功能。 Boolean b1 = 5>3; 等价于Boolean b1 = Boolean.valueOf(5>3); //优于Boolean b1 = new Boolean (5>3);

static void foo(){

boolean isTrue = 5>3; //基本类型

Boolean b1 = Boolean.TRUE; //静态变量创建的对象

Boolean b2 = Boolean.valueOf(isTrue);//静态工厂

Boolean b3 = 5>3;//自动装箱(autoboxing)

System.out.println("b1 == b2 ?" +(b1 == b2));

System.out.println("b1 == b3 ?" +(b1 == b3));

Boolean b4 = new Boolean(isTrue);////不宜使用

System.out.println("b1 == b4 ?" +(b1 == b4));//浪费内存、有创建实例的时间开销

} //这里b1、b2、b3指向同一个Boolean对象。

(7) 如果问你：String x ="abc";创建了几个对象？

准确的答案是：0或者1个。如果存在"abc"，则变量x持有"abc"这个引用，而不创建任何对象。

如果问你：String str1 = new String("abc"); 创建了几个对象？

准确的答案是：1或者2个。（至少1个在heap中）

(8) 对于int a = 3; int b = 3；

编译器先处理int a = 3；首先它会在栈中创建一个变量为a的引用，然后查找有没有字面值为3的地址，没找到，就开辟一个存放3这个字面值的地址，然后将a指向3的地址。接着处理int b = 3；在创建完b的引用变量后，由于在栈中已经有3这个字面值，便将b直接指向3的地址。这样，就出现了a与b同时均指向3的情况。

5、堆(Heap)和非堆(Non-heap)内存

按照官方的说法：“Java 虚拟机具有一个堆，堆是运行时数据区域，所有类实例和数组的内存均从此处分配。堆是在 Java 虚拟机启动时创建的。”

可以看出JVM主要管理两种类型的内存：堆和非堆。

简单来说堆就是Java代码可及的内存，是留给开发人员使用的；

非堆就是JVM留给自己用的，所以方法区、JVM内部处理或优化所需的内存(如JIT编译后的代码缓存)、每个类结构(如运行时常数池、字段和方法数据)以及方法和构造方法的代码都在非堆内存中。

堆内存分配

JVM初始分配的内存由-Xms指定，默认是物理内存的1/64；

JVM最大分配的内存由-Xmx指定，默认是物理内存的1/4。

默认空余堆内存小于40%时，JVM就会增大堆直到-Xmx的最大限制；空余堆内存大于70%时，JVM会减少堆直到-Xms的最小限制。

因此服务器一般设置-Xms、-Xmx相等以避免在每次GC 后调整堆的大小。

非堆内存分配

JVM使用-XX:PermSize设置非堆内存初始值，默认是物理内存的1/64；

由XX:MaxPermSize设置最大非堆内存的大小，默认是物理内存的1/4。

例子

-Xms256m

-Xmx1024m

-XX:PermSize=128M

-XX:MaxPermSize=256M

二、Java垃圾回收

1. JVM运行环境中垃圾对象的定义

一个对象创建后被放置在JVM的堆内存中，当永远不再引用这个对象时，它将被JVM在堆内存中回收。或 当对象在JVM运行空间中无法通过根集合(root set)到达时，这个对象就被称为垃圾对象。

2. 堆内存

* 在JVM启动时被创建；堆内存中所存储的对象可以被JVM自动回收，不能通过其他外部手段回收

* 堆内存可分为两个区域：新对象区和老对象区

-- 新对象区可分为三个小区：Eden区、From区、To区

Eden区用来保存新创建的对象，当Eden区中的对象满了之后，JVM将会做可达性测试，检测有哪些对象由根集合出发是不可达的，不可达的对象就会被JVM回收，并将所有的活动对象从Eden区拷到To区，此时一些对象将发生状态交换，有的对象就从To区被转移到From区。

3. JVM中对象的生命周期

* 创建阶段(步骤)

-- 为对象分配存储空间

-- 开始构造对象

-- 递归调用其超类的构造方法

-- 进行对象实例初始化与变量初始化

-- 执行构造方法体

* 应用阶段

-- 特征：系统至少维护着对象的一个强引用；所有对该对象引用强引用(除非显示声明为其它引用)

-- 强引用

指JVM内存管理器从根引用集合出发，遍寻堆中所有到达对象的路径。当到达某对象的任意路径都不含有引用对象时，对这个对象的引用就被称为强引用。

当内存不足时，JVM宁愿抛出OutOfMemeryError错误使程序停止，也不会靠收回具有强引用的对象来释放内存空间

-- 软引用

它能实现cache功能，防止最大限度的使用内存时引起的OutOfMemory异常，在内存不够用的时候jvm会自动回收Soft Reference。

软引用可以和一个引用队列(ReferenceQueue)联合使用，如果软引用所引用的对象被垃圾回收，java虚拟机就会把这个软引用加入到与之关联的引用队列中。

Java中提供软引用的包：java.lang.ref.SoftReference(后续详解)

软引用

实现cache功能,防止最大限度的使用内存时引起的OutOfMemory异常,在内存不够用的时候jvm会自动回收Soft Reference.软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。

Java代码

import java.lang.ref.SoftReference

//实现cache功能,最大限度利用内存

Test test = new Test();

SoftReference sr = new SoftRefence(test);

test = null;

if(sr.get() != null){

test = sr.get();

}else{

test = new Test();

sr = new SoftReference(test);

test = null;

}

Java代码

//创建一个强引用

String str = new String("hello");

//创建引用队列, <String>为范型标记，表明队列中存放String对象的引用

ReferenceQueue<String> rq = new ReferenceQueue<String>();

//创建一个弱引用，它引用"hello"对象，并且与rq引用队列关联

//<String>为范型标记，表明WeakReference会弱引用String对象

SoftReference<String> wf = new SoftReference<String>(str, rq);

str=null; //取消"hello"对象的强引用

String str1=wf.get(); //假如"hello"对象没有被回收，str1引用"hello"对象

//假如"hello"对象没有被回收，rq.poll()返回null

Reference<? extends String> ref=rq.poll();

-- 弱引用

只具有弱引用的对象有更短的生命周期，无论内存是否紧张，被垃圾回收器发现立即回收。弱引用可以和一个引用队列(ReferenceQueue)联合使用。

可分为长弱引用和短弱引用，长弱引用在对象的Finalize方法被GC调用后依然追踪对象

Java中提供弱引用的包：java.lang.ref.WeakReference

-- 虚引用

虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收。虚引用主要用来跟踪对象被垃圾回收的活动。

Phantom对象指一些执行完了finalize函数，并且为不可达对象，但是还没被GC回收的对象。这种对象可以辅助finalize进行一些后期的回收工作。

* 不可视阶段

-- 如果一个对象已使用完，并且在其可视区域不再使用，应该主动将其设置为null，即obj=null;这样可以帮助JVM及时地发现这个垃圾对象，并且可以及时地挥手该对象所占用的系统资源。

Java代码

package reference;

/*

WeakHashMap， 在这种Map中存放了键对象的弱引用，当一个键对象被垃圾回收，那么相应的值对象的引用会从Map中删除。WeakHashMap能够节约存储空间，可用 来缓存那些非必须存在的数据。

*/

import java.util.*;

import java.lang.ref.*;

class Key {

String id;

public Key(String id) {

this.id = id;

}

public String toString() {

return id;

}

public int hashCode() {

return id.hashCode();

}

public boolean equals(Object r) {

return (r instanceof Key) && id.equals(((Key) r).id);

}

public void finalize() {

System.out.println("Finalizing Key " + id);

}

}

class Value {

String id;

public Value(String id) {

this.id = id;

}

public String toString() {

return id;

}

public void finalize() {

System.out.println("Finalizing Value " + id);

}

}

public class MapCache {

public static void main(String[] args) throws Exception {

int size = 1000;

// 或者从命令行获得size的大小

if (args.length > 0)

size = Integer.parseInt(args[0]);

Key[] keys = new Key[size]; // 存放键对象的强引用

WeakHashMap<Key, Value> whm = new WeakHashMap<Key, Value>();

for (int i = 0; i < size; i++) {

Key k = new Key(Integer.toString(i));

Value v = new Value(Integer.toString(i));

if (i % 3 == 0)

keys[i] = k; // 使Key对象持有强引用

whm.put(k, v); // 使Key对象持有弱引用

}

// 催促垃圾回收器工作

System.gc();

// 把CPU让给垃圾回收器线程

Thread.sleep(8000);

}

}

4. Java中的析构方法finalize

finalize()方法常称之为终止器

protected void finalize(){

// finalization code here

}

对象即将被销毁时，有时需要做一些善后工作。可以把这些操作写在finalize()方法里。

Java终止器却是在对象被销毁时调用。一旦垃圾收集器准备好释放无用对象占用的存储空间，它首先调用那些对象的finalize()方法，然后才真正回收对象的内存。而被丢弃的对象何时被销毁，应用是无法获知的。大多数场合，被丢弃对象在应用终止后仍未销毁。到程序结束的时候，并非所有收尾模块都会得到调用。

5. 应用能干预垃圾回收吗？

在应用代码里控制JVM的垃圾回收运作是不可能的事。

对垃圾回收有两个途径。第一个就是将指向某对象的所有引用变量全部移走。这就相当于向JVM发了一个消息：这个对象不要了。第二个是调用库方法System.gc()。第一个是一个告知，而调用System.gc()也仅仅是一个请求。JVM接受这个消息后，并不是立即做垃圾回收，而只是对几个垃圾回收算法做了加权，使垃圾回收操作容易发生，或提早发生，或回收较多而已。

希望JVM及时回收垃圾，是一种需求。其实，还有相反的一种需要：在某段时间内最好不要回收垃圾。要求运行速度最快的实时系统，特别是嵌入式系统，往往希望如此。

Java的垃圾回收机制是为所有Java应用进程服务的，而不是为某个特定的进程服务的。因此，任何一个进程都不能命令垃圾回收机制做什么、怎么做或做多少。

6. 垃圾回收算法

* 引用计数

该算法在java虚拟机没被使用过，主要是循环引用问题，因为计数并不记录谁指向他，无法发现这些交互自引用对象。

-- 怎么计数？

当引用连接到对象时，对象计数加1

当引用离开作用域或被置为null时减1

-- 怎么回收？

遍历对象列表，计数为0就释放

-- 有什么问题？

循环引用问题。

* 标记算法

标记算法的思想是从堆栈和静态存储区的对象开始，遍历所有引用，标记活得对象。

对于标记后有两种处理方式：

(1) 停止-复制

-- 所谓停止，就是停止在运行的程序，进行垃圾回收

-- 所谓复制，就是将活得对象复制到另外一个堆上，以使内存更紧凑

-- 优点在于，当大块内存释放时，有利于整个内存的重分配

-- 有什么问题？

一、停止，干扰程序的正常运行，二，复制，明显耗费大量时间，三，如果程序比较稳定，垃圾比较少，那么每次重新复制量是非常大的，非常不合算

-- 什么时候启动停止-复制？

内存数量较低时，具体多低我也不知道

(2) 清除 也称标记-清除算法

-- 也就是将标记为非活得对象释放，也必须暂停程序运行

-- 优点就是在程序比较稳定，垃圾比较少的时候，速度比较快

-- 有什么问题?

很显然停止程序运行是一个问题，只清除也会造成很对内存碎片。

-- 为什么这2个算法都要暂停程序运行？

这是因为，如果不暂停，刚才的标记会被运行的程序弄乱