Handler避免内存泄漏

handler 会对activity持有引用,activity 退出页面的时候由于handler是非静态内部类会对外部类持有,简单做法是在onDestroy中remove

@Override
protected void onDestroy() {
    super.onDestroy();
    mHandler.removeCallbacksAndMessages(null);
}

同时将handler设置为static,这样就避免对activity 持有导致内存泄漏

private MyHandler handler;
// handler 避免内存泄漏
static class MyHandler extends Handler {
    private WeakReference<MainActivity> weakReference;

    public MyHandler(MainActivityactivity) {
        this.weakReference = new WeakReference<MainActivity>(activity);
    }

    @Override
    public void handleMessage(Message msg) {
        super.handleMessage(msg);
        MainActivityTwo activity = weakReference .get();
        if(activity !=null){

 			switch (msg.what) {
          		  case 1:
					activity . 去更新ui
             	   break;
        }
        }
     
    }
}
	 handler = new MyHandler(this);
    Message message = Message.obtain();
    message.what = 1;
    handler.handleMessage(message);


Message 建议用Message.obtain();
避免重复创建Message对象
/**
* Run the message queue in this thread. Be sure to call
	* {@link #quit()} to end the loop.
*/

public static void loop() {
final Looper me = myLooper();
if (me == null) {
    throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue;

// Make sure the identity of this thread is that of the local process,
// and keep track of what that identity token actually is.
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();

for (;;) {
    Message msg = queue.next(); // might block
    if (msg == null) {
        // No message indicates that the message queue is quitting.
        return;
    }

    // This must be in a local variable, in case a UI event sets the logger
    final Printer logging = me.mLogging;
    if (logging != null) {
        logging.println(">>>>> Dispatching to " + msg.target + " " +
                msg.callback + ": " + msg.what);
    }

    final long traceTag = me.mTraceTag;
    if (traceTag != 0) {
        Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
    }
    try {
        msg.target.dispatchMessage(msg);
    } finally {
        if (traceTag != 0) {
            Trace.traceEnd(traceTag);
        }
    }

    if (logging != null) {
        logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
    }

    // Make sure that during the course of dispatching the
    // identity of the thread wasn't corrupted.
    final long newIdent = Binder.clearCallingIdentity();
    if (ident != newIdent) {
        Log.wtf(TAG, "Thread identity changed from 0x"
                + Long.toHexString(ident) + " to 0x"
                + Long.toHexString(newIdent) + " while dispatching to "
                + msg.target.getClass().getName() + " "
                + msg.callback + " what=" + msg.what);
    }

    msg.recycleUnchecked();
}
}
这个方法是关键: 将消息分发出去
msg.target.dispatchMessage(msg);