2010-05-03

Java对象的4种引用类型（转）
文章分类:Java编程

   学了这么久的Java,才知道Java的对象引用类型有4种。所以，赶紧把不知道的东西补上！

    对于需要长期运行的应用程序来说，如果无用的对象所占用的内存空间不能得到即时的释放的话，那么在一个局部的时间段内便形成了事实上的内存泄露。

    以前我们学过，如果要及时地释放内存，最稳妥的方法就是使用完对象之后，立刻执行"object=null"语句。当然，这也是一种理想状态。

    JDK里面引入了4种对象引用类型，可以算是强行的调用System.gc()这个的垃圾回收的方法了。

  强引用：前面我们用的全部对象都是强引用类型的。这个就显示地执行"object=null"语句。

软引用：被软引用的对象，如果内存空间足够，垃圾回收器是不会回收它的，如果内存空间不足，垃圾回收器将回收这些对象占用的内存空间。软件引用对应着java.lang.ref.SoftReference类，一个对象如果要被软引用，只需将其作为参数传入SoftReference类的构造方法中就行了。感觉还是比较简单而且容易理解。

    弱引用：与前面的软引用相比，被弱引用了的对象拥有更短的内存时间（也就是生命周期）。垃圾回收器一旦发现了被弱引用的对象，不管当前内存空间是不是足够，都会回收它的内存，弱引用对应着java.lang.ref.WeakReference类，同样的道理。一个对象如果想被弱引用，只需将其作为参数传入WeakReference类的构造方法中就行了。

    虚引用:虚引用不是一种真实可用的引用类型，完全可以视为一种“形同虚设”的引用类型。设计虚引用的目的在于结合引用关联队列，实现对对象引用关系的跟踪（太高科技了，这几句话。目前还不知道是什么意思）。虚引用对应着java.lang.ref.PhantomReference类。一个对象如果要被虚引用，只需将其作为参数传入 PhantomReference类的构造方法中就行了，同时作为参数传入的还有引用关联队列java.lang.ref.ReferenceQueue 的对象实例。(没懂)

SoftReference,WeakReference,PhantomReference类都继承自java.lang.ref.Reference抽象类。Reference抽象类定义了clear() 方法用于撤销引用关系，get()方法用于返回被引用的对象。

    摘抄一段代码示例:

Java代码

  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.Set;  
  6. import java.util.HashSet;  
  8. public class TestReferences  
  9. {  
  10. public static void main(String[] args)  
  11.     {  
  12. int length=10;  
  14. //创建length个MyObject对象的强引用
  15.         Set<MyObject> a = new HashSet<MyObject>();  
  16. for(int i = 0; i < length; i++)  
  17.         {  
  18.             MyObject ref=new MyObject("Hard_" + i);  
  19.             System.out.println("创建强引用：" +ref);  
  20.             a.add(ref);  
  21.         }  
  22. //a=null;
  23.         System.gc();  
  25. //创建length个MyObject对象的软引用
  26.         Set<SoftReference<MyObject>> sa = new HashSet<SoftReference<MyObject>>();  
  27. for(int i = 0; i < length; i++)  
  28.         {  
  29.             SoftReference<MyObject> ref=new SoftReference<MyObject>(new MyObject("Soft_" + i));  
  30.             System.out.println("创建软引用：" +ref.get());  
  31.             sa.add(ref);  
  32.         }  
  33.         System.gc();  
  35. //创建length个MyObject对象的弱引用
  36.         Set<WeakReference<MyObject>> wa = new HashSet<WeakReference<MyObject>>();  
  37. for(int i = 0; i < length; i++)  
  38.         {  
  39.             WeakReference<MyObject> ref=new WeakReference<MyObject>(new MyObject("Weak_" + i));  
  40.             System.out.println("创建弱引用：" +ref.get());  
  41.             wa.add(ref);  
  42.         }  
  43.         System.gc();  
  45. //创建length个MyObject对象的虚引用
  46.         ReferenceQueue<MyObject> rq = new ReferenceQueue<MyObject>();  
  47.         Set<PhantomReference<MyObject>> pa = new HashSet<PhantomReference<MyObject>>();  
  48. for(int i = 0; i < length; i++)  
  49.         {  
  50.             PhantomReference<MyObject> ref = new PhantomReference<MyObject>(new MyObject("Phantom_" + i), rq);  
  51.             System.out.println("创建虚引用：" +ref.get());  
  52.             pa.add(ref);  
  53.         }  
  54.         System.gc();  
  55.     }  
  56. }  
  58. class MyObject  
  59. {  
  60. private String id;  
  62. public MyObject(String id)  
  63.     {  
  64. this.id = id;  
  65.     }  
  67. public String toString()  
  68.     {  
  69. return id;  
  70.     }  
  72. public void finalize()  
  73.     {  
  74.         System.out.println("回收对象：" + id);  
  75.     }  
  76. }   
import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;
import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;
import java.util.Set;
import java.util.HashSet;

public class TestReferences
{
    public static void main(String[] args)
    {
        int length=10;
       
        //创建length个MyObject对象的强引用
        Set<MyObject> a = new HashSet<MyObject>();
        for(int i = 0; i < length; i++)
        {
            MyObject ref=new MyObject("Hard_" + i);
            System.out.println("创建强引用：" +ref);
            a.add(ref);
        }
        //a=null;
        System.gc();
       
        //创建length个MyObject对象的软引用
        Set<SoftReference<MyObject>> sa = new HashSet<SoftReference<MyObject>>();
        for(int i = 0; i < length; i++)
        {
            SoftReference<MyObject> ref=new SoftReference<MyObject>(new MyObject("Soft_" + i));
            System.out.println("创建软引用：" +ref.get());
            sa.add(ref);
        }
        System.gc();

        //创建length个MyObject对象的弱引用
        Set<WeakReference<MyObject>> wa = new HashSet<WeakReference<MyObject>>();
        for(int i = 0; i < length; i++)
        {
            WeakReference<MyObject> ref=new WeakReference<MyObject>(new MyObject("Weak_" + i));
            System.out.println("创建弱引用：" +ref.get());
            wa.add(ref);
        }
        System.gc();

        //创建length个MyObject对象的虚引用
        ReferenceQueue<MyObject> rq = new ReferenceQueue<MyObject>();
        Set<PhantomReference<MyObject>> pa = new HashSet<PhantomReference<MyObject>>();
        for(int i = 0; i < length; i++)
        {
            PhantomReference<MyObject> ref = new PhantomReference<MyObject>(new MyObject("Phantom_" + i), rq);
            System.out.println("创建虚引用：" +ref.get());
            pa.add(ref);
        }
        System.gc();
    }
}

class MyObject
{
    private String id;

    public MyObject(String id)
    {
        this.id = id;
    }

    public String toString()
    {
        return id;
    }

    public void finalize()
    {
        System.out.println("回收对象：" + id);
    }
}

java中synchronized用法(转) | java nio之 clear(),flip(),rewind(),reset ...

评论
发表评论