Java垃圾回收(一)

在Java中，它的内存管理包括两个方面：内存分配和内存回收，这两个方面的工作都是由JVM自动完成的，降低了Java程序员的学习难度，避免了像C/C++直接操作内存的危险。但这也使很多程序员不关心内存分配的问题，导致很多程序低效耗费内存。

Java语言规范没有明确的说明JVM使用哪种垃圾回收算法。一般常用的算法有下列几种：

引用记数法(Reference Counting Collector)
tracing算法(Tracing Collector)
compacting算法(Compating Collector)
Copying算法(Cpoing Collector)
generation算法(Genrational Collector)也就是分代回收
adaptive算法

1.Java在内存中的状态

开始先看一个例子：

Person.java

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

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方法开始的对象引用图的话就是这样的（顶点是对象和引用，有向边是引用关系）：

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

可达状态：在一个对象创建后，有一个以上的引用变量和它关联，则它处于可达状态。
可恢复状态：如果程序中某个对象不再有引用变量和其相关联，则它将先进入可恢复状态，此时从有向图的起始顶点不能再导航到该对象，在这个状态下，系统的垃圾回收机制准备回收该对象的所占用的内存，在回收之前。系统会调用finalize()方法进行资源清理，如果资源整理后重新让一个以上引用变量和该对象关联，则该对象的状态会再次变为可达状态，否则就会进入不可达状态。
不可达状态：当对象的所有关联都被切断，且系统调用finalize()方法进行资源清理之后依旧没有使该对象变为可达状态，则这个对象将永久性失去引用并且变成不可达状态，系统才会真正的去回收该对象所占用的资源。

2. Java对象的4种引用

强引用：创建一个对象并把这个对象直接赋值给一个变量引用，eg:Person person = new Person("sunny");此时不管系统资源有多么紧张都绝对不会被回收。

软引用：通过SoftReference类实现，eg:SoftReference<Person> p = new SoftReference<Person>(new Person（“Rain”))；内存非常紧张的时候会被回收，其他时候不会被回收，因此在使用之前要判断是否已经被回收了。例如：

class AB {
protected void finalize() {
    System.out.println("finalize.....");
}
}

public class JavaTest {
    public static void main(String[] args) {
        for (int i=0 ; i < 10000; i ++) {
            new SoftReference<AB> (new AB());
        }
    }
}
结果为：finalize.....
finalize.....
finalize.....
结果不一定，看个人电脑了，也可能没有输出，需要创建更多的对象来逼着JVM回收软引用。

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

class AB {
    protected void finalize() {
        System.out.println("finalize.....");
    }
}
public class JavaTest {
    public static void main(String[] args) {
        WeakReference<AB> wr = new WeakReference<AB> (new AB());
        System.gc();
    }
}
输出结果为:finalize.....
强制回收垃圾，若引用就会直接被回收

虚引用 ：不能单独使用，主要是用于追踪对象被垃圾回收的状态。通过PhantomReference类和引用队列ReferenceQueue类联合使用实现,例子如下。
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 rq = new ReferenceQueue();

//创建一个虚引用，让此虚引用引用到person对象

PhantomReference pr = new PhantomReference(person, rq);

//切断person引用变量和对象的引用

person = null;

//试图取出虚引用所引用的对象

//发现程序并不能通过虚引用访问被引用对象，所以此处输出为null

System.out.println(pr.get());

//强制垃圾回收

System.gc();

System.runFinalization();

//因为一旦虚引用中的对象被回收后，该虚引用就会进入引用队列中

//所以用队列中最先进入队列中引用与pr进行比较，输出true

System.out.println(rq.poll() == pr);

}

}

输出结果为： null true

3. 垃圾回收器分类

串行回收(只用一个cpu)和并行回收(多个cpu才有用):串行回收是不管系统有多少个CPU，始终只用一个CPU来执行垃圾回收操作，而并行回收就是把整个回收工作拆分成对各部分，每个部分由一个CPU负责，从而让多个CPU并行回收。并行回收的执行效率很高，但是复杂度增加，另外也有一些副作用，如内存碎片增加。
并发执行和应用程序停止 ：应用程序停止(stop-the-world)即在其垃圾回收方式在执行的时候同时会导致应用程序的暂停。并发执行的垃圾回收虽然不会导致应用程序的暂停，由于需要边执行应用程序边垃圾回收(可能在回收的时候修改对象，因此和应用程序的执行存在冲突问题)，并发执行的系统开销比Stop-the-world高，而且需要更多的堆内存。
压缩和不压缩和复制
- 支持压缩的垃圾回收器(标记-压缩 =标记清楚+压缩)会把所有的可达对象搬迁到一端，然后直接清理掉边界以外的内存，减少了内存碎片。
- 不支持压缩的垃圾回收器(标记-清除)要遍历两次，第一次先从根开始访问，标记所有可达状态的对象，第二次遍历整个内存区域，对为标记可达状态的对象进行回收处理。这种回收方式不压缩，不需要额外的内存，但需要遍历两次，会产生碎片。
- 复制式的垃圾回收器：将堆内存分成两个相同的控件，从根开始访问每个可达对象，将A的所有可达对象都复制到B空间，然后一次性回收所有A空间。遍历空间的成本小，不会产生碎片，但需要巨大的复制成本和较多的内存。

4.内存管理技巧

尽量使用直接量。 eg:String s = “hello world”;
使用StringBuilder和StringBuffer进行字符串的连接等操作;
尽早释放无用对象;
少使用静态变量;
缓存常用的对象，可以用开源的开源缓存实现。eg:OSCache,Ehcache;
尽量不使用finalize()方法；
在必要的时候考虑多使用软饮用SoftReference;

时间： 2024-10-30 21:03:40

Java垃圾回收(一)