android 中的引用

转自：http://www.jiangwenrou.com/java%E7%9A%84%E5%9B%9B%E7%A7%8D%E5%BC%95%E7%94%A8.html

参考链接 http://www.infoq.com/cn/articles/cf-java-garbage-references

总体思路为：由于handle要在不同avtivity之间传递消息，隐含着其有一个activity的引用存放在message queen中，所以当一个activity要切换的时候（比如用户按下退出键），android的垃圾回收机制本来是想回收这个activity的，但是由于handle对应的message queen中还有引用，所以无法回收，内存泄漏。如果对于handle引用的这些activity都用弱引用来指向，那么一旦activity自己的强引用消失了，那么这些弱引用也自动会消失，这块内存会被释放掉。而之所以使用ReferenceQueue的原因是为了每次方便判断这个弱引用还在不在，是不是已经被系统回收掉了。

准确的说，应该是在一个线程中要使用handler的时候需要这样做，这里说的线程，对于activity的话就是一个UI线程，一个继承了activity的类中要使用一个handler对象，或者一个继承了Thread的类中要使用一个handler对象，这两个类都需要建一个弱引用的ReferenceQueue。之后调用ReferenceQueue.get()函数测试一下当前引用是否已经被回收

Java中存在四种引用，它们分别是：强引用(StrongReference),软引用(SoftReference),弱引用(WeakReference),虚引用(PhantomReference).下面分别介绍:
强引用(StrongReference)
强引用是使用最普遍的引用。如果一个对象具有强引用，那垃圾回收器绝不会回收它。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足的问题。

实际编码中最常见的一种引用类型。常见形式如：A a = new A();等。强引用本身存储在栈内存中，其存储指向对内存中对象的地址。一般情况下，当对内存中的对象不再有任何强引用指向它时，垃圾回收机器开始考虑可能要对此内存进行的垃圾回收。如当进行编码：a = null，此时，刚刚在堆中分配地址并新建的a对象没有其他的任何引用，当系统进行垃圾回收时，堆内存将被垃圾回收。

SoftReference、WeakReference、PhantomReference都是类java.lang.ref.Reference的子类。Reference作为抽象基类，定义了其子类对象的基本操作。Reference子类都具有如下特点：1.Reference子类不能无参化直接创建，必须至少以强引用对象为构造参数，创建各自的子类对象；2.因为1中以强引用对象为构造参数创建对象，因此，使得原本强引用所指向的堆内存中的对象将不再只与强引用本身直接关联，与Reference的子类对象的引用也有一定联系。且此种联系将可能影响到对象的垃圾回收。

根据不同的子类对象对其指示对象（强引用所指向的堆内存中的对象）的垃圾回收不同的影响特点，分别形成了三个子类，即SoftReference、WeakReference和PhantomReference。

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

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

软引用的一般使用形式如下：

A a = new A();SoftReference<A> srA = new SoftReference<A>(a);

通过对象的强引用为参数，创建了一个SoftReference对象，并使栈内存中的wrA指向此对象。此时，进行如下编码：a = null，对于原本a所指向的A对象的垃圾回收有什么影响呢？先直接看一下下面一段程序的输出结果：

import java.lang.ref.SoftReference;public class ReferenceTest {     public static void main(String[] args) {        A a = new A();         SoftReference srA = new SoftReference(a);        a = null;         if (srA.get() == null) {            System.out.println("a对象进入垃圾回收流程");         } else {             System.out.println("a对象尚未被回收" + srA.get());         }         // 垃圾回收        System.gc();        if (srA.get() == null) {             System.out.println("a对象进入垃圾回收流程");         } else {            System.out.println("a对象尚未被回收" + srA.get());         }     } } class A { }

输出结果为：

a对象尚未被回收A@4807ccf6a对象尚未被回收A@4807ccf6

当 a = null后，堆内存中的A对象将不再有任何的强引用指向它，但此时尚存在srA引用的对象指向A对象。当第一次调用srA.get()方法返回此指示对象时，由于垃圾回收器很有可能尚未进行垃圾回收，此时get()是有结果的，这个很好理解。当程序执行System.gc();强制垃圾回收后，通过srA.get()，发现依然可以得到所指示的A对象，说明A对象并未被垃圾回收。那么，软引用所指示的对象什么时候才开始被垃圾回收呢？需要满足如下两个条件：

1.当其指示的对象没有任何强引用对象指向它；2.当虚拟机内存不足时。因此，SoftReference变相的延长了其指示对象占据堆内存的时间，直到虚拟机内存不足时垃圾回收器才回收此堆内存空间.

弱引用(WeakReference)
弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。

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

同样的，软引用的一般使用形式如下：

A a = new A();WeakReference<A> wrA = new WeakReference<A>(a);

当没有任何强引用指向此对象时，其垃圾回收又具有什么特性呢？

import java.lang.ref.WeakReference;public class ReferenceTest {    public static void main(String[] args) {        A a = new A();        WeakReference wrA = new WeakReference(a);        a = null;        if (wrA.get() == null) {            System.out.println("a对象进入垃圾回收流程");        } else {            System.out.println("a对象尚未被回收" + wrA.get());        }        // 垃圾回收        System.gc();        if (wrA.get() == null) {            System.out.println("a对象进入垃圾回收流程");        } else {            System.out.println("a对象尚未被回收" + wrA.get());        }    }}class A {}

输出结果为：

a对象尚未被回收A@52e5376aa对象进入垃圾回收流程

输出的第一条结果解释同上。当进行垃圾回收后，wrA.get()将返回null，表明其指示对象进入到了垃圾回收过程中。因此，对弱引用特点总结为：

WeakReference不改变原有强引用对象的垃圾回收时机，一旦其指示对象没有任何强引用对象时，此对象即进入正常的垃圾回收流程。

那么，依据此特点，很可能有疑问：WeakReference存在又有什么意义呢？

其主要使用场景见于：当前已有强引用指向强引用对象，此时由于业务需要，需要增加对此对象的引用，同时又不希望改变此引用的垃圾回收时机，此时WeakReference正好符合需求，常见于一些与生命周期的场景中。

下面给出一个Android中关于WeakReference使用的场景——结合静态内部类和WeakReference来解决Activity中可能存在的Handler内存泄露问题。

Activity中我们需要新建一个线程获取数据，使用handler - sendMessage方式。下面是这一过程的一般性代码：

public class MainActivity extends Activity {    //...    private int page;    private Handler handler = new Handler() {        @Override        public void handleMessage(Message msg) {            if (msg.what == 1) {                //...                page++;            } else {                //...            }        };    };    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);        //...        new Thread(new Runnable() {            @Override            public void run() {                //..                Message msg = Message.obtain();                msg.what = 1;                //msg.obj = xx;                handler.sendMessage(msg);            }        }).start();        //...    }}

IDE将会看到警示信息：This Handler class should be static or leaks might occur ..点击查看此信息，其详情中对问题进行了说明并给出了建议性的解决方案。

Issue: Ensures that Handler classes do not hold on to a reference to an outer classId: HandlerLeakSince this Handler is declared as an inner class, it may prevent the outer class from being garbage collected.If the Handler is using a Looper or MessageQueue for a thread other than the main thread, then there is no issue. If the Handler is using the Looper or MessageQueue of the main thread, you need to fix your Handler declaration, as follows: Declare the Handler as a static class;In the outer class, instantiate a WeakReference to the outer class and pass this object to your Handler when you instantiate the Handler; Make all references to members of the outer class using the WeakReference object.

大致的意思是建议将Handler定义成内部静态类，并在此静态内部类中定义一个WeakReference的引用，由于指示外部的Activity对象。

问题分析：

Activity具有自身的生命周期，Activity中新开启的线程运行过程中，可能此时用户按下了Back键，或系统内存不足等希望回收此Activity，由于Activity中新起的线程并不会遵循Activity本身的什么周期，也就是说，当Activity执行了onDestroy,由于线程以及Handler 的HandleMessage的存在，使得系统本希望进行此Activity内存回收不能实现，因为非静态内部类中隐性的持有对外部类的引用，导致可能存在的内存泄露问题。

因此，在Activity中使用Handler时，一方面需要将其定义为静态内部类形式，这样可以使其与外部类（Activity）解耦，不再持有外部类的引用，同时由于Handler中的handlerMessage一般都会多少需要访问或修改Activity的属性，此时，需要在Handler内部定义指向此Activity的WeakReference，使其不会影响到Activity的内存回收同时，可以在正常情况下访问到Activity的属性。

Google官方给出的建议写法为：

public class MainActivity extends Activity {    //...    private int page;    private MyHandler mMyHandler = new MyHandler(this);    private static class MyHandler extends Handler {        private WeakReference wrActivity;        public MyHandler(MainActivity activity) {            this.wrActivity = new WeakReference(activity);        }        @Override        public void handleMessage(Message msg) {            if (wrActivity.get() == null) {                return;            }            MainActivity mActivity = wrActivity.get();            if (msg.what == 1) {                //...                mActivity.page++;            } else {                //...            }        }    }    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);        //...        new Thread(new Runnable() {            @Override            public void run() {                //..                Message msg = Message.obtain();                msg.what = 1;                //msg.obj = xx;                mMyHandler.sendMessage(msg);            }        }).start();        //...    }}

对于SoftReference和WeakReference，还有一个构造器参数为ReferenceQueue，当SoftReference或WeakReference所指示的对象确实被垃圾回收后，其引用将被放置于ReferenceQueue中。注意上文中，当SoftReference或WeakReference的get()方法返回null时，仅是表明其指示的对象已经进入垃圾回收流程，此时对象不一定已经被垃圾回收。而只有确认被垃圾回收后，如果ReferenceQueue，其引用才会被放置于ReferenceQueue中。

看下面的一个例子：

public class ReferenceTest {    public static void main(String[] args) {        A a = new A();        WeakReference wrA = new WeakReference(a);        a = null;        if (wrA.get() == null) {            System.out.println("a对象进入垃圾回收流程");        } else {            System.out.println("a对象尚未被回收" + wrA.get());        }        // 垃圾回收        System.gc();        if (wrA.get() == null) {            System.out.println("a对象进入垃圾回收流程");        } else {            System.out.println("a对象尚未被回收" + wrA.get());        }    }}class A {    @Override    protected void finalize() throws Throwable {        super.finalize();        System.out.println("in A finalize");    }}

输出结果为：

对象尚未被回收A@46993aaaa对象被回收in A finalize

由此，也验证了上文中的“进入垃圾回收流程”的说法。下面结合ReferenceQueue，看一段代码：

public class ReferenceTest {    public static void main(String[] args) {        A a = new A();        ReferenceQueue rq = new ReferenceQueue();        WeakReference wrA = new WeakReference(a, rq);        a = null;        if (wrA.get() == null) {            System.out.println("a对象进入垃圾回收流程");        } else {            System.out.println("a对象尚未被回收" + wrA.get());        }        System.out.println("rq item:" + rq.poll());        // 垃圾回收        System.gc();        if (wrA.get() == null) {            System.out.println("a对象进入垃圾回收流程");        } else {            System.out.println("a对象尚未被回收" + wrA.get());        }        /*        try {            Thread.sleep(1000);        } catch (InterruptedException e) {            e.printStackTrace();        }        */        System.out.println("rq item:" + rq.poll());    }}class A {    @Override    protected void finalize() throws Throwable {        super.finalize();        System.out.println("in A finalize");    }}

输出结果为：

a对象尚未被回收A@302b2c81rq item:nulla对象进入垃圾回收流程rq item:nullin A finalize

由此，验证了“仅进入垃圾回收流程的SoftReference或WeakReference引用尚未被加入到ReferenceQueue”。

public class ReferenceTest {    public static void main(String[] args) {        A a = new A();        ReferenceQueue rq = new ReferenceQueue();        WeakReference wrA = new WeakReference(a, rq);        a = null;        if (wrA.get() == null) {            System.out.println("a对象进入垃圾回收流程");        } else {            System.out.println("a对象尚未被回收" + wrA.get());        }        System.out.println("rq item:" + rq.poll());        // 垃圾回收        System.gc();        if (wrA.get() == null) {            System.out.println("a对象进入垃圾回收流程");        } else {            System.out.println("a对象尚未被回收" + wrA.get());        }        try {            Thread.sleep(1);        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println("rq item:" + rq.poll());    }}class A {    @Override    protected void finalize() throws Throwable {        super.finalize();        System.out.println("in A finalize");    }}

输出结果为：

a对象尚未被回收A@6276e1db
rq item:null
a对象进入垃圾回收流程
in A finalize
rq item:java.lang.ref.WeakReference@645064f
由此，证实了上述说法。

虚引用(PhantomReference)
“虚引用”顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。

虚引用主要用来跟踪对象被垃圾回收器回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列（ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。

与SoftReference或WeakReference相比，PhantomReference主要差别体现在如下几点：

1.PhantomReference只有一个构造函数PhantomReference(T referent, ReferenceQueue

prA.get():nullrq item:java.lang.ref.PhantomReference@1da12fc0

代码中的Thread.sleep(1);作用与上例中相同，都是确保垃圾回收线程能够执行。否则，进进入垃圾回收流程而没有真正被垃圾回收的指示对象的虚引用是不会被加入到PhantomReference中的。

与WeakReference相同，PhantomReference并不会改变其指示对象的垃圾回收时机。且可以总结出：ReferenceQueue的作用主要是用于监听SoftReference /WeakReference/PhantomReference的指示对象是否已经被垃圾回收。

Reference
Reference内部通过一个 {Reference} next 的字段来构建一个Reference类型的单向链表。另外其内部还包含一个 ReferenceQueue

public void run() {        for (;;) {        Reference r;        synchronized (lock) {　　　　　　  // 检查pending是否为null            if (pending != null) {            r = pending;            Reference rn = r.next;            pending = (rn == r) ? null : rn;            r.next = r;            } else {            try {　　　　　　　　　 // pending为null时，则将当前线程进入wait set，等待GC执行后执行notifyAll                lock.wait();            } catch (InterruptedException x) { }            continue;            }        }        // Fast path for cleaners        if (r instanceof Cleaner) {            ((Cleaner)r).clean();            continue;        }        // 追加到对应的引用队列中        ReferenceQueue q = r.queue;        if (q != ReferenceQueue.NULL) q.enqueue(r);        }    }

注意：由于通过静态代码块进行线程的创建和启动，因此Reference的所有子类实例均通过同一个线程进行向各自的引用队列追加引用对象的操作。

WeakHashMap
由于WeakHashMap的键对象为弱引用，因此当发生GC时键对象所指向的内存空间将被回收，被回收后再调用size、clear或put等直接或间接调用私有expungeStaleEntries方法的实例方法时，则这些键对象已被回收的项目（Entry）将被移除出键值对集合中。

下列代码将发生OOM

public static void main(String[] args) throws Exception {        Listbyte[][], byte[][]>> maps = new ArrayListbyte[][], byte[][]>>();        for (int i = 0; i < 1000; i++) {            WeakHashMap<byte[][], byte[][]> d = new WeakHashMap<byte[][], byte[][]>();            d.put(new byte[1000][1000], new byte[1000][1000]);            maps.add(d);            System.gc();            System.err.println(i);        }    }

而下面的代码因为集合的Entry被移除因此不会发生OOM

public static void main(String[] args) throws Exception {        Listbyte[][], byte[][]>> maps = new ArrayListbyte[][], byte[][]>>();        for (int i = 0; i < 1000; i++) {            WeakHashMap<byte[][], byte[][]> d = new WeakHashMap<byte[][], byte[][]>();            d.put(new byte[1000][1000], new byte[1000][1000]);            maps.add(d);            System.gc();            System.err.println(i);            for (int j = 0; j < i; j++) {                // 触发移除Entry操作                System.err.println(j+  " size" + maps.get(j).size());            }        }    }

更多相关文章

随机推荐