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{sKDUGQzuzX
private Hashtable table = new Hashtable（）;
public A（）{ table = new Hashtable（）;
// 这里应该去掉，因为table已经被初始化。
}
这样就new了两个Hashtable，但是却只使用了一个。另外一个则没有被引用。而被忽略掉。浪费了内存。并且由于进行了两次new操作。也影响了代码的执行速度。
应用阶段：即该对象至少有一个引用在维护他。
不可视阶段：即超出该变量的作用域。这里有一个很好的做法，因为JVM在GC的时候并不是马上进行回收，而是要判断对象是否被其他引用在维护。所以，这个时候如果我们在使用完一个对象以后对其obj=null或者obj.doSomething（）操作，将其标记为空，可以帮助JVM及时发现这个垃圾http://www.rixia.cc对象。
不可到达阶段：就是在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帮助文档。我们主要介绍程序设计方面的http://www.rixia.cc性能提高。
JAVA程序设计中有关内存管理的其他经验：
根据JVM内存管理的工作原理，可以通过一些技巧和方式让JVM做GC处理时更加有效。，从而提高内存使用和缩短GC的执行时间。
1，尽早释放无用对象的引用。即在不使用对象的引用后设置为空，可以加速GC的工作。（当然如果是返回值。..。.）
2，尽量少用finalize函数，此函数是JAVA给程序员提供的一个释放对象或资源的机会，但是却会加大GC工作量。
3，如果需要使用到图片，可以使用soft应用类型，它可以尽可能将图片读入内存而不引起OutOfMemory.
4，注意集合数据类型的数据结构，往往数据结构越复杂，GC工作量更大，处理更复杂。
5，尽量避免在默认构造器（构造函数）中创建，初始化大量的对象。
6，尽量避免强制系统做垃圾回收。会增加系统做垃圾回收的最终时间降http://www.rixia.cc低性能。
7，尽量避免显式申请数组，如果不得不申请数组的话，要尽量准确估算数组大小。
8，如果在做远程方法调用。要尽量减少传递的对象大小。或者使用瞬间值避免不必要数据的传递。
9，尽量在合适的情况下使用对象池来提高系统性能减少内存开销，当然，对象池不能过于庞大，会适得其反.

在你写的程序中 编好的代码全部运行在 JVM 即 java 虚拟机，这时你的代码就会占内存。而内存中运行着jvm ， jvm 的 heap 和 stack 都是有限大的。你的程序代码 过多占用内存。导致硬件出问题 系统运行不流畅 慢 ，这时 就产生了GC GC自动回收那些 已死的代码对象 或 已经无用的类

判断无用的类 标准
1.该类所有的实例都以回收。也就是Java堆中不存在该类的任何实例
2. 加载该类的classLoader已经被回收
3.该类对应的java.lang.class 对象没有在任何地方被引用， 无法在任何地方通过反射访问该类的方法

无用的类 和对象就会自动被 GC垃圾回收机制回收。。。。

对于 GC 来说，当程序员创建对象时，GC 就开始监控这个对象的地址、大小以及使用情况。
通常，GC 采用有向图的方式记录和管理堆(heap) 中的所有对象。通过这种方式确定哪些对
象是"可达的"，哪些对象是"不可达的"。当GC 确定一些对象为"不可达"时，GC 就有责任回
收这些内存空间。程序员可以手动执行 System.gc()，通知 GC 运行，但是 Java 语言
规范并不保证 GC 一定会执行。

回收机制就是 当一些资源被创建使用之后或不在调用的话 就会变成垃圾，垃圾的话会占用空间，这时候就需要释放空间给其他程序使用，所以JAVA拥有自动垃圾回收机制，会在适当的时候自动调用垃圾回收 释放资源，程序员也可以手动调用释放资源等等。
如：
public class A {
String str;
public A(String str){
this.str=str;
}
public String toString(){
return str;
}
@Override
protected void finalize() throws Throwable {
System.out.println("我是"+str+".我被回收了..");
}
public static void main(String[] args) {
A a=new A("李四");
a=null;
System.gc(); //运行结果 我是李四.我被回收了..
}
}

Java中的对象没有作用域的概念，只有对象的引用才有作用域。在用new创建出一个对象之后，垃圾回收器就会自动监控该对象，并且会辨别是否需要释放内存，不需要开发者手动释放，所以可以很好的防止内存泄漏。
JVM的垃圾回收器采用的是一种分代（generational ）回收策略，共分为三个代：
1.Young（年轻代）
年 轻代分三个区。一个Eden区，两个Survivor区。大部分对象在Eden区中生成。当Eden区满时，还存活的对象将被复制到Survivor区 （两个中的一个），当这个Survivor区满时，此区的存活对象将被复制到另外一个Survivor区，当这个Survivor去也满了的时候，从第一 个Survivor区复制过来的并且此时还存活的对象，将被复制“年老区(Tenured)”。需要注意，Survivor的两个区是对称的，没先后关 系，所以同一个区中可能同时存在从Eden复制过来 对象，和从前一个Survivor复制过来的对象，而复制到年老区的只有从第一个Survivor去过来的对象。而且，Survivor区总有一个是空的。
2.Tenured（年老代）
年老代存放从年轻代存活的对象。一般来说年老代存放的都是生命期较长的对象。
3.Perm（持久代）
用 于存放静态文件，如Java类、方法等。持久代对垃圾回收没有显著影响，但是有些应用可能动态生成或者调用一些class，例如Hibernate等， 在这种时候需要设置一个比较大的持久代空间来存放这些运行过程中新增的类。持久代大小通过-XX:MaxPermSize=进行设置。

可以Wikipedia上搜索garbage collection