转自:http://www.admin10000.com/document/1671.html

在Java中,它的内存管理包括两方面:内存分配(创建Java对象的时候)和内存回收,这两方面工作都是由JVM自动完成的,降低了Java程序员的学习难度,避免了像C/C++直接操作内存的危险。但是,也正因为内存管理完全由JVM负责,所以也使Java很多程序员不再关心内存分配,导致很多程序低效,耗内存。因此就有了Java程序员到最后应该去了解JVM,才能写出更高效,充分利用有限的内存的程序。

 1.Java在内存中的状态

  首先我们先写一个代码为例子:

  Person.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package test;
  
 import java.io.Serializable;
  
 public class Person implements Serializable {
  
     static final long serialVersionUID = 1L;
  
     String name; // 姓名
      
     Person friend;    //朋友
  
     public Person() {}
      
     public Person(String name) {
         super();
         this.name = name;
     }
 }

  Test.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package test;
  
  
 public class Test{
  
     public static void main(String[] args) {
         Person p1 = new Person("Kevin");
         Person p2 = new Person("Rain");
         Person p3 = new Person("Sunny");
          
         p1.friend = p2;
         p3 = p2;
         p2 = null;
     }
 }

  把上面Test.java中main方面里面的对象引用画成一个从main方法开始的对象引用图的话就是这样的(顶点是对象和引用,有向边是引用关系):

  当程序运行起来之后,把它在内存中的状态看成是有向图后,可以分为三种:

  1)可达状态:在一个对象创建后,有一个以上的引用变量引用它。在有向图中可以从起始顶点导航到该对象,那它就处于可达状态。

  2)可恢复状态:如果程序中某个对象不再有任何的引用变量引用它,它将先进入可恢复状态,此时从有向图的起始顶点不能再导航到该对象。在这个状态下,系统的垃圾回收机制准备回收该对象的所占用的内存,在回收之前,系统会调用finalize()方法进行资源清理,如果资源整理后重新让一个以上引用变量引用该对象,则这个对象会再次变为可达状态;否则就会进入不可达状态。

  3)不可达状态:当对象的所有关联都被切断,且系统调用finalize()方法进行资源清理后依旧没有使该对象变为可达状态,则这个对象将永久性失去引用并且变成不可达状态,系统才会真正的去回收该对象所占用的资源。

  上述三种状态的转换图如下:

 2.Java对对象的4种引用

  1)强引用 :创建一个对象并把这个对象直接赋给一个变量,eg :Person person = new Person("sunny"); 不管系统资源有么的紧张,强引用的对象都绝对不会被回收,即使他以后不会再用到。

  2)软引用 :通过SoftReference类实现,eg : SoftReference<Person> p = new SoftReference<Person>(new Person("Rain"));,内存非常紧张的时候会被回收,其他时候不会被回收,所以在使用之前要判断是否为null从而判断他是否已经被回收了。

  3)弱引用 :通过WeakReference类实现,eg : WeakReference<Person> p = new WeakReference<Person>(new Person("Rain"));不管内存是否足够,系统垃圾回收时必定会回收。

  4)虚引用 :不能单独使用,主要是用于追踪对象被垃圾回收的状态。通过PhantomReference类和引用队列ReferenceQueue类联合使用实现,eg :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package test;
  
 import java.lang.ref.PhantomReference;
 import java.lang.ref.ReferenceQueue;
 public class Test{
  
     public static void main(String[] args) {
         //创建一个对象
         Person person = new Person("Sunny");   
         //创建一个引用队列   
         ReferenceQueue<Person> rq = new ReferenceQueue<Person>();
         //创建一个虚引用,让此虚引用引用到person对象
         PhantomReference<Person> pr = new PhantomReference<Person>(person, rq);
         //切断person引用变量和对象的引用
         person = null;
         //试图取出虚引用所引用的对象
         //发现程序并不能通过虚引用访问被引用对象,所以此处输出为null
         System.out.println(pr.get());
         //强制垃圾回收
         System.gc();
         System.runFinalization();
         //因为一旦虚引用中的对象被回收后,该虚引用就会进入引用队列中
         //所以用队列中最先进入队列中引用与pr进行比较,输出true
         System.out.println(rq.poll() == pr);
     }
 }

  运行结果:

 3.Java垃圾回收机制

  其实Java垃圾回收主要做的是两件事:1)内存回收 2)碎片整理

  3.1垃圾回收算法

  1)串行回收(只用一个CPU)和并行回收(多个CPU才有用):串行回收是不管系统有多少个CPU,始终只用一个CPU来执行垃圾回收操作,而并行回收就是把整个回收工作拆分成多个部分,每个部分由一个CPU负责,从而让多个CPU并行回收。并行回收的执行效率很高,但复杂度增加,另外也有一些副作用,如内存随便增加。

  2)并发执行和应用程序停止 :应用程序停止(Stop-the-world)顾名思义,其垃圾回收方式在执行垃圾回收的同时会导致应用程序的暂停。并发执行的垃圾回收虽然不会导致应用程序的暂停,但由于并发执行垃圾需要解决和应用程序的执行冲突(应用程序可能在垃圾回收的过程修改对象),因此并发执行垃圾回收的系统开销比Stop-the-world高,而且执行时需要更多的堆内存。

  3)压缩和不压缩和复制 :

  ①支持压缩的垃圾回收器(标记-压缩 = 标记清除+压缩)会把所有的可达对象搬迁到一起,然后将之前占用的内存全部回收,减少了内存碎片。

  ②不压缩的垃圾回收器(标记-清除)要遍历两次,第一次先从跟开始访问所有可达对象,并将他们标记为可达状态,第二次便利整个内存区域,对未标记可达状态的对象进行回收处理。这种回收方式不压缩,不需要额外内存,但要两次遍历,会产生碎片

  ③复制式的垃圾回收器:将堆内存分成两个相同空间,从根(类似于前面的有向图起始顶点)开始访问每一个关联的可达对象,将空间A的全部可达对象复制到空间B,然后一次性回收空间A。对于该算法而言,因为只需访问所有的可达对象,将所有的可达对象复制走之后就直接回收整个空间,完全不用理会不可达对象,所以遍历空间的成本较小,但需要巨大的复制成本和较多的内存。

  3.2堆内存的分代回收

  1)分代回收的依据:

  ①对象生存时间的长短:大部分对象在Young期间就被回收

  ②不同代采取不同的垃圾回收策略:新(生存时间短)老(生存时间长)对象之间很少存在引用

  2) 堆内存的分代:

  ①Young代 :

  Ⅰ回收机制 :因为对象数量少,所以采用复制回收。

  Ⅱ组成区域 :由1个Eden区和2个Survivor区构成,同一时间的两个Survivor区,一个用来保存对象,另一个是空的;每次进行Young代垃圾回收的时候,就把Eden,From中的可达对象复制到To区域中,一些生存时间长的就复制到了老年代,接着清除Eden,From空间,最后原来的To空间变为From空间,原来的From空间变为To空间。

  Ⅲ对象来源 :绝大多数对象先分配到Eden区,一些大的对象会直接被分配到Old代中。

  Ⅳ回收频率 :因为Young代对象大部分很快进入不可达状态,因此回收频率高且回收速度快

  ②Old代 :

  Ⅰ回收机制 :采用标记压缩算法回收。

  Ⅱ对象来源 :1.对象大直接进入老年代。

         2.Young代中生存时间长的可达对象

  Ⅲ回收频率 :因为很少对象会死掉,所以执行频率不高,而且需要较长时间来完成。

  ③Permanent代 :

  Ⅰ用      途 :用来装载Class,方法等信息,默认为64M,不会被回收

  Ⅱ对象来源 :eg:对于像Hibernate,Spring这类喜欢AOP动态生成类的框架,往往会生成大量的动态代理类,因此需要更多的Permanent代内存。所以我们经常在调试Hibernate,Spring的时候经常遇到java.lang.OutOfMemoryError:PermGen space的错误,这就是Permanent代内存耗尽所导致的错误。

  Ⅲ回收频率 :不会被回收

  3.3常见的垃圾回收器

  1)串行回收器(只使用一个CPU):Young代采用串行复制算法;Old代使用串行标记压缩算法(三个阶段:标记mark—清除sweep—压缩compact),回收期间程序会产生暂停,

  2)并行回收器:对Young代采用的算法和串行回收器一样,只是增加了多CPU并行处理; 对Old代的处理和串行回收器完全一样,依旧是单线程。

  3)并行压缩回收器:对Young代处理采用与并行回收器完全一样的算法;只是对Old代采用了不同的算法,其实就是划分不同的区域,然后进行标记压缩算法:

  ① 将Old代划分成几个固定区域;

  ② mark阶段(多线程并行),标记可达对象;

  ③ summary阶段(串行执行),从最左边开始检验知道找到某个达到数值(可达对象密度小)的区域时,此区域及其右边区域进行压缩回收,其左端为密集区域

  ④ compact阶段(多线程并行),识别出需要装填的区域,多线程并行的把数据复制到这些区域中。经此过程后,Old代一端密集存在大量活动对象,另一端则存在大块空间。

  4)并发标识—清理回收(CMS):对Young代处理采用与并行回收器完全一样的算法;只是对Old代采用了不同的算法,但归根待地还是标记清理算法:

  ① 初始标识(程序暂停):标记被直接引用的对象(一级对象);

  ② 并发标识(程序运行):通过一级对象寻找其他可达对象;

  ③ 再标记(程序暂停):多线程并行的重新标记之前可能因为并发而漏掉的对象(简单的说就是防遗漏)

  ④ 并发清理(程序运行)

 4.内存管理小技巧

  1)尽量使用直接量,eg:String javaStr = "小学徒的成长历程";

  2)使用StringBuilder和StringBuffer进行字符串连接等操作;

  3)尽早释放无用对象;

  4)尽量少使用静态变量;

  5)缓存常用的对象:可以使用开源的开源缓存实现,eg:OSCache,Ehcache;

  6)尽量不使用finalize()方法;

  7)在必要的时候可以考虑使用软引用SoftReference。

[转载]Java的内存回收机制的更多相关文章

  1. Java的内存回收机制

    原文出处: cnblogs-小学徒V 在Java中,它的内存管理包括两方面:内存分配(创建Java对象的时候)和内存回收,这两方面工作都是由JVM自动完成的,降低了Java程序员的学习难度,避免了像C ...

  2. 从Java虚拟机的内存区域、垃圾收集器及内存分配原则谈Java的内存回收机制

    一.引言: 在Java中我们只需要轻轻地new一下,就可以为实例化一个类,并分配对应的内存空间,而后似乎我们也可以不用去管它,Java自带垃圾回收器,到了对象死亡的时候垃圾回收器就会将死亡对象的内存回 ...

  3. Java jvm 内存回收机制

    http://blog.csdn.net/yaerfeng/article/details/51291903 在Java中,它的内存管理包括两方面:内存分配(创建Java对象的时候)和内存回收,这两方 ...

  4. Java的内存回收机制详解X

    http://blog.csdn.net/yqlakers/article/details/70138786 1 垃圾回收的意义 在C++中,对象所占的内存在程序结束运行之前一直被占用,在明确释放之前 ...

  5. 转载 JAVA gc垃圾回收机制

    thanks:https://m.oschina.net/u/123553 一.GC概要 JVM堆相关知识    为什么先说JVM堆?    JVM的堆是Java对象的活动空间,程序中的类的对象从中分 ...

  6. Java技术专题之JVM逻辑内存回收机制研究图解版

    一.引言 JVM虚拟机内存回收机曾迷惑了不少人,文本从JVM实现机制的角度揭示JVM内存回收的原理和机制. 一.Java平台逻辑架构 二.JVM物理结构 通过从JVM物理结构图我们可以看到: 1.JV ...

  7. Android 操作系统的内存回收机制(转载)

    Android 操作系统的内存回收机制(转载) Android APP 的运行环境 Android 是一款基于 Linux 内核,面向移动终端的操作系统.为适应其作为移动平台操作系统的特殊需要,谷歌对 ...

  8. Android内存优化5 了解java GC 垃圾回收机制3

    引言 接App优化之内存优化(序), 作为App优化系列中内存优化的一个小部分. 由于内存相关知识比较生涩, 内存优化中使用到的相关工具, 也有很多专有名词. 对Java内存管理, GC, Andro ...

  9. Java进阶3. 内存回收机制

    Java进阶3. 内存回收机制 20131029 前言: 学过C++的都知道,C++中内存需要程序员自己维护.说道这里,很多开发的同学就感觉很痛苦,当他转向Java的时候,就会说你看Java多好啊,程 ...

随机推荐

  1. ES6学习笔记(三)

    ES6加强了对Unicode的支持,并且扩展了字符串对象. 1.字符的Unicode表示法 JavaScript允许采用\uxxxx形式表示一个字符,其中"xxxx"表示字符的码点 ...

  2. php入门常量

    常量像变量一样,用于临时存储一个值,但是常量在许多方面与变量不同. 常量:1.是在程序执行期间无法改变数据,常量的作用域是全局的.2.常量的命名与与变量相似,只是不带美元符号“$”.一个有效的常量名由 ...

  3. phpcms V9静态判断会员登录状态的方法

    phpcms v9如何在任意地方判断会员的登录状态呢?在php中是比较好判断的,代码如下 <?php if (!$_userid){ echo"会员没有登录"; }else ...

  4. TDBAdvGrid 只读状态下复制功能

    DataSource1.AutoEdit := false;

  5. Spark Streaming揭秘 Day33 checkpoint的使用

    Spark Streaming揭秘 Day33 checkpoint的使用 今天谈下sparkstreaming中,另外一个至关重要的内容Checkpoint. 首先,我们会看下checkpoint的 ...

  6. UVA 11059

    Given a sequence of integers S = {S1, S2, . . . , Sn}, you should determine what is the value of the ...

  7. 使用Pod集成Bugtags填坑记

    最近某朋友的朋友的创业公司新出了一个工具叫Bugtags,说是可以让APP测试变得so easy,于是动手来做1.1.0的版本集成,先把WEB首页贴在下面,感兴趣的同学可以去look一下:https: ...

  8. Visual Studio 中TODO List的使用

    http://msdn.microsoft.com/en-us/library/txtwdysk.aspx 工欲善其事,必先利其器 When the Task List is open, you ca ...

  9. linux 安装firefox

    从火狐官网下载的firefox-9.0.1.tar.bz2解压后,进入firefox文件夹,执行./firefox会提示缺少库,故采用yum安装Firefox9.1.切换到root用户 su - 2. ...

  10. 指针 取地址& 解引用 *

    aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAtAAAACNCAIAAAARutrLAAAgAElEQVR4nOydd3wcxd3/R13uvdsUY2