Android内存优化：Handler

在避免内存泄露的文章中，Handler经常被提起，原因就是对象的强引用，比如一个Activity内部有一个Handler对象在运行

		private Handler handler;
		handler = new Handler(){
			@Override
			public void handleMessage(Message msg) {
				// TODO Auto-generated method stub
				super.handleMessage(msg);
			}
		};
		Message message = new Message();
		message.what = 1;
		handler.sendMessage(message);

当我们使用上面代码创建一个Handler时，IDE就会给我提示

This Handler class should be static or leaks might occur (com.example.androidtest.MainActivity.2)
告诉我们，会产生内存泄露。

当Activity关闭时，Handler不一定处理完毕，但是Handler对Activity有引用关系，导致GC无法回收Activity对象，造成内存泄露。那么Handler为什么会这样呢，那就看看它的实现吧。

在Handler对象中会隐式的引用到Activity，这就形成了强引用，也是造成内存泄露的原因。
Handler是用来处理消息的，那么就要有一个对象进行消息的分发，这就是Looper
当进程启动时，ActivityThread会创建一个Looper对象，Looper对象的研究，参考老罗的文章  http://blog.csdn.net/luoshengyang/article/details/6817933

    public static void prepareMainLooper() {
		//调用prepare创建Looper
        prepare(false);
        synchronized (Looper.class) {
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            sMainLooper = myLooper();
        }
    }

    private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
		//这里new了一个Looper对象
        sThreadLocal.set(new Looper(quitAllowed));
    }
	//sThreadLocal是个静态变量
	static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

Looper中有一个MessageQueue对象，保存着消息队列

	final MessageQueue mQueue;

当Handler发送消息时，消息会被加入到MessageQueue中，并且Message的target对象和Handler进行了绑定，这样这个消息也就对Activity进行了引用，只要这个消息在，GC就无法回收已经关闭的Activity

handler.sendMessage发送消息最终调用下面的方法，持有了Activity

    public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
        MessageQueue queue = mQueue;
        if (queue == null) {
            RuntimeException e = new RuntimeException(
                    this + " sendMessageAtTime() called with no mQueue");
            Log.w("Looper", e.getMessage(), e);
            return false;
        }
        return enqueueMessage(queue, msg, uptimeMillis);
    }

    private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
				//这里就是，消息持有了handler对象，handler持有Activity
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }

当Handler创建时，会关联到上面创建的Looper对象，这样消息机制就可以运转起来了。

    public Handler(Callback callback, boolean async) {
        if (FIND_POTENTIAL_LEAKS) {
            final Class<? extends Handler> klass = getClass();
			//看看这里，如果是匿名类或者成员类或者局部类，并且不是静态对象，系统就会提示警告，有内存泄露的危险
            if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
                    (klass.getModifiers() & Modifier.STATIC) == 0) {
                Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
                    klass.getCanonicalName());
            }
        }
		//取出Looper
        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

知道了上面的原因，那么为了避免内存泄露，我们可以采用以下方法，具体实现网上有很多文章，这里不再罗列。
1、用static声明handler，静态类不会引用外部类
2、如果Handler中必须用到Activity，那就用WeakReference去引用
3、在Activity结束或暂停的事件中，removeMessages或者removeCallbacksAndMessages将消息队列中的消息移除（避免满足上面两条后，当Activity关闭了，但是Handler还未处理到，造成内存泄露）