java语言从诞生开始，一个吸引人眼球的功能就是垃圾回收，想一想C++中时不时的内存泄漏，当时感觉写java代码直是一种享受呀。     和.NET的引用计数不同，java的垃圾回收机制采取的是有向图的方式来实现，具体的说，java程序中的每个线程对象就可以看作是一个有向图的起点，有向边从栈中的引用者指向堆中的引用对象。在这个有向图中，如果一个对象和根节点之间是可达的，那么这个对象就是有效的，反之，这个对象就是可以被回收的。采取这样一种机制的优点是可以有效的避免循环引用。     java语言中的对象引用分为以下几种：强引用、软引用、弱引用和虚引用。     强引用就是我们经常用到的引用，这种引用在对象被标识为无效后，不会被立刻回收，除非写o = null;这种语句。     软引用，如果一个被软引用的对象被标识为无效后，在内存控件足够的情况下，不会被回收，在内存紧张的情况下，会被回收的。     弱引用，如果一个被弱引用的对象被标识为无效，那么对象会被立刻回收。     虚引用，这是一种不太真实可用的引用类型，它的主要用途是结合引用关联队列，实现对对象引用关系的跟踪。     四种引用的Sample如下：

1 import java.lang.ref.SoftReference;

2 import java.lang.ref.WeakReference;

3 import java.lang.ref.PhantomReference;

4 import java.lang.ref.ReferenceQueue;

5 import java.util.HashSet;

6 import java.util.Set;

7

8 class MyObject {

9    private String id;

10   

11    public MyObject(String id) {

12        this.id = id;

13    }

14   

15    public String toString() {

16        return id;

17    }

18   

19    public void finalize() {

20        System.out.println("Object Collect: " + id);

21    }

22}

23

24  public class ReferenceTest {

25   

26    public static void main(String[] args) {

27        // TODO Auto-generated method stub

28       

29        int length = 10;

30       

31        Set<MyObject> a = new HashSet<MyObject>();

32        for (int i = 0; i < length; i++) {

33            MyObject ref = new MyObject("Hard_" + i);

34            System.out.println("Create Strong Refence: " + ref);

35            a.add(ref);

36        }

37        System.out.println();

38        System.gc();

39        System.out.println();

40       

41        Set<SoftReference<MyObject>> sa = new HashSet<SoftReference<MyObject>>();

42        for (int i = 0; i < length; i++) {

43            SoftReference<MyObject> ref = new SoftReference<MyObject>(new MyObject("Soft_" + i));

44            System.out.println("Create Soft Refence: " + ref);

45            sa.add(ref);

46        }

47        System.out.println();

48        System.gc();

49        System.out.println();

50       

51        Set<WeakReference<MyObject>> wa = new HashSet<WeakReference<MyObject>>();

52        for (int i = 0; i < length; i++) {

53            WeakReference<MyObject> ref = new WeakReference<MyObject>(new MyObject("Weak_" + i));

54            System.out.println("Create Weak Refence: " + ref);

55            wa.add(ref);

56        }

57        System.out.println();

58        System.gc();

59        System.out.println();

60

61        ReferenceQueue rq = new ReferenceQueue<MyObject>();

62        Set<PhantomReference<MyObject>> pa = new HashSet<PhantomReference<MyObject>>();

63        for (int i = 0; i < length; i++) {

64            //MyObject ref = new MyObject("Hard_" + i);

65            PhantomReference<MyObject> ref = new PhantomReference<MyObject>(new MyObject("Phantom_" + i), rq);

66            System.out.println("Create Phantom Refence: " + ref);

67            pa.add(ref);

68        }

69        System.out.println();

70        System.gc();

71        System.out.println();

72    }   

    执行结果如下：

Create Strong Refence: Hard_0 Create Strong Refence: Hard_1 Create Strong Refence: Hard_2 Create Strong Refence: Hard_3 Create Strong Refence: Hard_4 Create Strong Refence: Hard_5 Create Strong Refence: Hard_6 Create Strong Refence: Hard_7 Create Strong Refence: Hard_8 Create Strong Refence: Hard_9

Create Soft Refence: java.lang.ref.SoftReference@1270b73 Create Soft Refence: java.lang.ref.SoftReference@60aeb0 Create Soft Refence: java.lang.ref.SoftReference@16caf43 Create Soft Refence: java.lang.ref.SoftReference@66848c Create Soft Refence: java.lang.ref.SoftReference@8813f2 Create Soft Refence: java.lang.ref.SoftReference@1d58aae Create Soft Refence: java.lang.ref.SoftReference@83cc67 Create Soft Refence: java.lang.ref.SoftReference@e09713 Create Soft Refence: java.lang.ref.SoftReference@de6f34 Create Soft Refence: java.lang.ref.SoftReference@156ee8e

Create Weak Refence: java.lang.ref.WeakReference@e0e1c6 Create Weak Refence: java.lang.ref.WeakReference@6ca1c Create Weak Refence: java.lang.ref.WeakReference@1bf216a Create Weak Refence: java.lang.ref.WeakReference@12ac982 Create Weak Refence: java.lang.ref.WeakReference@1389e4 Create Weak Refence: java.lang.ref.WeakReference@c20e24 Create Weak Refence: java.lang.ref.WeakReference@2e7263 Create Weak Refence: java.lang.ref.WeakReference@157f0dc Create Weak Refence: java.lang.ref.WeakReference@863399 Create Weak Refence: java.lang.ref.WeakReference@a59698

Create Phantom Refence: java.lang.ref.PhantomReference@5740bb Create Phantom Refence: java.lang.ref.PhantomReference@5ac072 Create Phantom Refence: java.lang.ref.PhantomReference@109a4c Create Phantom Refence: java.lang.ref.PhantomReference@201f9 Create Phantom Refence: java.lang.ref.PhantomReference@1cf8583 Create Phantom Refence: java.lang.ref.PhantomReference@14693c7 Create Phantom Refence: java.lang.ref.PhantomReference@901887 Create Phantom Refence: java.lang.ref.PhantomReference@3a6727 Create Phantom Refence: java.lang.ref.PhantomReference@4a65e0 Create Phantom Refence: java.lang.ref.PhantomReference@665753

Object Collect: Phantom_6 Object Collect: Phantom_9 Object Collect: Phantom_8 Object Collect: Phantom_7 Object Collect: Phantom_5 Object Collect: Phantom_4 Object Collect: Phantom_3 Object Collect: Phantom_2 Object Collect: Phantom_1 Object Collect: Phantom_0 Object Collect: Weak_9 Object Collect: Weak_8 Object Collect: Weak_7 Object Collect: Weak_6 Object Collect: Weak_5 Object Collect: Weak_4 Object Collect: Weak_3 Object Collect: Weak_2 Object Collect: Weak_1 Object Collect: Weak_0

虽然java语言采取了比.NET更好的垃圾回收机制，但是它也存在内存泄漏的时候，考虑以下情况：

1 Vector v = new Vector(10);

2 for (int i = 0; i < 10; i++) {

3     object o = new object();

4     v.add(o);

5     o = null;

6 }

对于每次建立的对象o，虽然最后通过o = null;语句来表明它是无效的，但是我们可以通过Vector来引用到它，这样，如果在Vector使用完毕后没有被显示的释放，即没有v = null;的话，这里就产生了内存泄漏。