java代码垃圾回收

A. java垃圾回收器如何工作

java回收器有gc

以下是工作原理：

强引用（StrongReference）

这个就不多说，我们写代码天天在用的就是强引用。如果一个对象被被人拥有强引用，那么垃圾回收器绝不会回收它。当内存空间不足，Java 虚拟机宁愿抛出 OutOfMemoryError 错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足问题。

Java 的对象是位于 heap 中的，heap 中对象有强可及对象、软可及对象、弱可及对象、虚可及对象和不可到达对象。应用的强弱顺序是强、软、弱、和虚。对于对象是属于哪种可及的对象，由他的最强的引用决定。如下

代码：

String abc=newString("abc");//1

SoftReference<String> softRef=newSoftReference<String>(abc);//2

WeakReference<String> weakRef =newWeakReference<String>(abc);//3

abc=null;//4

softRef.clear();//5

第一行在 heap 堆中创建内容为“abc”的对象，并建立 abc 到该对象的强引用，该对象是强可及的。

第二行和第三行分别建立对 heap 中对象的软引用和弱引用，此时 heap 中的 abc 对象已经有 3 个引用，显然此时 abc 对象仍是强可及的。

第四行之后 heap 中对象不再是强可及的，变成软可及的。

第五行执行之后变成弱可及的。

软引用（SoftReference）

如果一个对象只具有软引用，那么如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。

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

软引用是主要用于内存敏感的高速缓存。在 jvm 报告内存不足之前会清除所有的软引用，这样以来 gc 就有可能收集软可及的对象，可能解决内存吃紧问题，避免内存溢出。什么时候会被收集取决于 gc 的算法和 gc 运行时可用内存的大小。当 gc 决定要收集软引用时执行以下过程,以上面的 softRef 为例：

1 首先将 softRef 的 referent（abc）设置为 null，不再引用 heap 中的 new String("abc")对象。

2 将 heap 中的 new String("abc")对象设置为可结束的(finalizable)。

3 当 heap 中的 new String("abc")对象的 finalize()方法被运行而且该对象占用的内存被释放， softRef

被添加到它的 ReferenceQueue(如果有的话)中。

注意:对 ReferenceQueue 软引用和弱引用可以有可无，但是虚引用必须有。

被 Soft Reference 指到的对象，即使没有任何 Direct Reference，也不会被清除。一直要到 JVM 内存

不足且没有 Direct Reference 时才会清除，SoftReference 是用来设计 object-cache 之用的。如此一来

SoftReference 不但可以把对象 cache 起来，也不会造成内存不足的错误 （OutOfMemoryError）。

弱引用（WeakReference）

如果一个对象只具有弱引用， 那该类就是可有可无的对象， 因为只要该对象被 gc 扫描到了随时都会把它干掉。弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程， 因此不一定会很快发现那些只具有弱引用的对象。弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java 虚拟机就会把这个弱引用加入到与之关联的引用队列中。

虚引用（PhantomReference）

"虚引用"顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个

对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收。虚引用主要用来跟踪对象被

垃圾回收的活动。

虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列（ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。

建立虚引用之后通过 get 方法返回结果始终为 null,通过源代码你会发现,虚引用通向会把引用的对象写进

referent,只是 get 方法返回结果为 null。先看一下和 gc 交互的过程再说一下他的作用。

1 不把 referent 设置为 null, 直接把 heap 中的 new String("abc")对象设置为可结束的(finalizable)。

2 与软引用和弱引用不同, 先把 PhantomRefrence 对象添加到它的 ReferenceQueue 中.然后在释放虚可及的对象。

B. java中垃圾回收机制的原理

java中垃圾回收机制的原理
推荐一篇文章：
对高性能JAVA代码之内存管理
更甚者你写的代码，GC根本就回收不了，直接系统挂掉。GC是一段程序，不是智能，他只回收他认为的垃圾，而不是回收你认为的垃圾。
GC垃圾回收：
Grabage Collection相信学过JAVA的人都知道这个是什么意思。但是他是如何工作的呢？
首先，JVM在管理内存的时候对于变量的管理总是分新对象和老对象。新对象也就是开发者new出来的对象，但是由于生命周期短，那么他占用的内存并不是马上释放，而是被标记为老对象，这个时候该对象还是要存在一段时间。然后由JVM决定他是否是垃圾对象，并进行回收。
所以我们可以知道，垃圾内存并不是用完了马上就被释放，所以就会产生内存释放不及时的现象，从而降低了内存的使用。而当程序浩大的时候。这种现象更为明显，并且GC的工作也是需要消耗资源的。所以，也就会产生内存浪费。
JVM中的对象生命周期里谈内存回收：
对象的生命周期一般分为7个阶段：创建阶段，应用阶段，不可视阶段，不可到达阶段，可收集阶段，终结阶段，释放阶段。
创建阶段：首先大家看一下，如下两段代码：
test1：
for（ int i=0; i《10000; i++）
Object obj=new Object（）;
test2：
Object obj=null;
for（ int i=0; i《10000; i++）
obj=new Object（）;
这两段代码都是相同的功能，但是显然test2的性能要比test1性能要好，内存使用率要高，这是为什么呢？原因很简单，test1每次执行for循环都要创建一个Object的临时对象，但是这些临时对象由于JVM的GC不能马上销毁，所以他们还要存在很长时间，而test2则只是在内存中保存一份对象的引用，而不必创建大量新临时变量，从而降低了内存的使用。
另外不要对同一个对象初始化多次。例如：
public class A{
private Hashtable table = new Hashtable（）;
public A（）{ table = new Hashtable（）;
// 这里应该去掉，因为table已经被初始化。
}
这样就new了两个Hashtable，但是却只使用了一个。另外一个则没有被引用。而被忽略掉。浪费了内存。并且由于进行了两次new操作。也影响了代码的执行速度。
应用阶段：即该对象至少有一个引用在维护他。
不可视阶段：即超出该变量的作用域。这里有一个很好的做法，因为JVM在GC的时候并不是马上进行回收，而是要判断对象是否被其他引用在维护。所以，这个时候如果我们在使用完一个对象以后对其obj=null或者obj.doSomething（）操作，将其标记为空，可以帮助JVM及时发现这个垃圾对象。
不可到达阶段：就是在JVM中找不到对该对象的直接或者间接的引用。
可收集阶段，终结阶段，释放阶段：此为回收器发现该对象不可到达，finalize方法已经被执行，或者对象空间已被重用的时候。
JAVA的析构方法：
可能不会有人相信，JAVA有析构函数？ 是的，有。因为JAVA所有类都继承至Object类，而finalize就是Object类的一个方法，这个方法在JAVA中就是类似于C++析构函数。一般来说可以通过重载finalize方法的形式才释放类中对象。如：
public class A{
public Object a;
public A（）{ a = new Object ;}
protected void finalize（） throws java.lang.Throwable{
a = null; // 标记为空，释放对象
super.finalize（）; // 递归调用超类中的finalize方法。
}
}
当然，什么时候该方法被调用是由JVM来决定的。..。..。..。..。..。..。..。.
一般来说，我们需要创建一个destory的方法来显式的调用该方法。然后在finalize也对该方法进行调用，实现双保险的做法。
由于对象的创建是递归式的，也就是先调用超级类的构造，然后依次向下递归调用构造函数，所以应该避免在类的构造函数中初始化变量，这样可以避免不必要的创建对象造成不必要的内存消耗。当然这里也就看出来接口的优势。
数组的创建：
由于数组需要给定一个长度，所以在不确定数据数量的时候经常会创建过大，或过小的数组的现象。造成不必要的内存浪费，所以可以通过软引用的方式来告诉JVM及时回收该内存。（软引用，具体查资料）。
例如：
Object obj = new char［10000000000000000］;
SoftReference ref = new SoftReference（obj）;
共享静态存储空间：
我们都知道静态变量在程序运行期间其内存是共享的，因此有时候为了节约内存工件，将一些变量声明为静态变量确实可以起到节约内存空间的作用。但是由于静态变量生命周期很长，不易被系统回收，所以使用静态变量要合理，不能盲目的使用。以免适得其反。
因此建议在下面情况下使用：
1，变量所包含的对象体积较大，占用内存过多。
2，变量所包含对象生命周期较长。
3，变量所包含数据稳定。
4，该类的对象实例有对该变量所包含的对象的共享需求。（也就是说是否需要作为全局变量）。
对象重用与GC：
有的时候，如数据库操作对象，一般情况下我们都需要在各个不同模块间使用，所以这样的对象需要进行重用以提高性能。也有效的避免了反复创建对象引起的性能下降。
一般来说对象池是一个不错的注意。如下：
public abstarct class ObjectPool{
private Hashtable locked，unlocked;
private long expirationTime;
abstract Object create（）;
abstract void expire（ Object o）;
abstract void validate（ Object o）;
synchronized Object getObject（）{。..};
synchronized void freeObject（Object o）{。..};
这样我们就完成了一个对象池，我们可以将通过对应的方法来存取删除所需对象。来维护这快内存提高内存重用。
当然也可以通过调用System.gc（）强制系统进行垃圾回收操作。当然这样的代价是需要消耗一些cpu资源。
不要提前创建对象：
尽量在需要的时候创建对象，重复的分配，构造对象可能会因为垃圾回收做额外的工作降低性能。
JVM内存参数调优：
强制内存回收对于系统自动的内存回收机制会产生负面影响，会加大系统自动回收的处理时间，所以应该尽量避免显式使用System.gc（），
JVM的设置可以提高系统的性能。例如：
java -XX:NewSize=128m -XX:MaxNewSize=128m -XX:SurvivorRatio=8 -Xms512m -Xmx512m
具体可以查看java帮助文档。我们主要介绍程序设计方面的性能提高。
JAVA程序设计中有关内存管理的其他经验：
根据JVM内存管理的工作原理，可以通过一些技巧和方式让JVM做GC处理时更加有效。，从而提高内存使用和缩短GC的执行时间。
1，尽早释放无用对象的引用。即在不使用对象的引用后设置为空，可以加速GC的工作。（当然如果是返回值。..。.）
2，尽量少用finalize函数，此函数是JAVA给程序员提供的一个释放对象或资源的机会，但是却会加大GC工作量。
3，如果需要使用到图片，可以使用soft应用类型，它可以尽可能将图片读入内存而不引起OutOfMemory.
4，注意集合数据类型的数据结构，往往数据结构越复杂，GC工作量更大，处理更复杂。
5，尽量避免在默认构造器（构造函数）中创建，初始化大量的对象。
6，尽量避免强制系统做垃圾回收。会增加系统做垃圾回收的最终时间降低性能。
7，尽量避免显式申请数组，如果不得不申请数组的话，要尽量准确估算数组大小。
8，如果在做远程方法调用。要尽量减少传递的对象大小。或者使用瞬间值避免不必要数据的传递。
9，尽量在合适的情况下使用对象池来提高系统性能减少内存开销，当然，对象池不能过于庞大，会适得其反.