Android异步消息处理机制之Handler、Looper、Message_handler(looper.getmainlooper())

为什么用异步消息处理机制？

因为Android UI线程是线程不安全的，在子线程中更新UI会直接程序崩溃，另外当UI线程需要执行一个比较耗时的操作的话(IO操作，网络通信等)，若是执行时间超过5s，程序会直接ANR，为了解决上述问题，可以使用异步消息处理机制 Handler，Handler有两大用处：

• 在未来的某个时间点执行调度Message或者Runnable对象
• 将执行的操作以队列形式放到其他线程中，并可以实现线程间通信

Handler、Looper、Message

通常在主线程中创建Handler，在子线程中执行耗时操作，并在子线程中将执行结果通过handler传递到主线程中刷新UI，首先在Activity中创建handler：

 Handler handler = new Handler(Looper.getMainLooper()) {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 1:
                    tv_text.setText("更新UI");
                    break;
                default:
                    break;
            }
        }
    };
1
2
3
4
5
6
7
8
9
10
11
12

新起一个子线程：

 new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    //模拟耗时操作
                    Thread.sleep(2000);
                    //模拟子线程处理完数据，通过handler将结果传到主线程
                    handler.sendEmptyMessage(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
1
2
3
4
5
6
7
8
9
10
11
12
13

整个流程：首先在子线程中处理耗时操作，当子线程处理完后，通过handler将处理结果传到主线程用来刷新UI，通过handler就完成了线程间的通信，那么handler内部是怎么运行的呢？

Handler源码

 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());
            }
        }

        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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

可以看到首先通过Looper.myLooper()来创建了一个Looper对象，如果Looper为空，则抛出异常Can't create handler inside thread that has not called Looper.prepare()，来看Looper.myLooper()：

public static @Nullable Looper myLooper() {
        return sThreadLocal.get();
    }
1
2
3

从sThreadLocal对象中取出Looper，如果sThreadLocal中有Looper存在就返回Looper，如果没有则返回null了，sThreadLocal对象什么时候set的呢？答案是Looper.prepare()：

static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }
1
2
3
4
5
6
7

Looper.prepare()只能被调用一次，即一个handler只能对应一个Looper，如果被多次调用，则会抛出异常：Only one Looper may be created per thread，如果在子线程使用handler，必须首先调用Looper.prepare()来创建Looper；但是我们在主线程中并没有调用Looper.prepare()，也没有崩溃呀！这是因为系统已经为我们创建好了：

public final class ActivityThread {
    public static void main(String[] args) {
        ......//省略其他代码
        Looper.prepareMainLooper();
        ......//省略其他代码
        Looper.loop();

        throw new RuntimeException("Main thread loop unexpectedly exited");
    }
}
1
2
3
4
5
6
7
8
9
10

来看Looper.prepareMainLooper()方法：

 public static void prepareMainLooper() {
        prepare(false);
        synchronized (Looper.class) {
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            sMainLooper = myLooper();
        }
    }
1
2
3
4
5
6
7
8
9

因此我们的主线程一直有Looper对象，再来看Looper.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;
        ......//省略其他代码
        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();
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

ActivityThread的main()方法执行 Looper.loop()后，主线程就开始无限循环处理消息，没有消息时阻塞等待，既然无限循环为什么主线程没有因为死循环而卡死呢？原因可以参考下这篇文章：Android中为什么主线程不会因为Looper.loop()里的死循环卡死？
handler创建完成，就可以发送Message了，来看Message都有哪些成员变量：

//Message的识别码，用来区别不同的Message
public int what;
//arg1 arg2都是用来传递整形数据
public int arg1;
public int arg2;
//可以传递任意数据
public Object obj;
1
2
3
4
5
6
7

创建一个新消息，如：

Message message = Message.obtain();//建议使用Message.obtain()而不是new Message()，Message.obtain()可以从消息池中取消息
 message.what = 1; //识别码为1
 message.arg1 = 100; //携带int类型数 100和101
 message.arg2 = 101;
 message.obj = MyObject;//携带MyObject对象
 Bundle bundle = new Bundle(); //封装bundle
 bundle.putString("key", "value");
 message.setData(bundle);
 handler.sendMessage(message); //通过handler将Message送到消息队列中
1
2
3
4
5
6
7
8
9

来看handler都有哪些处理Message的常用方法：

上面表格中除了直接发送Message外，还可以用post一个runnable，看post()方法：

 public final boolean post(Runnable r)
    {
     //通过getPostMessage()方法将Runnable 转换成消息
       return  sendMessageDelayed(getPostMessage(r), 0);
    }
1
2
3
4
5

 private static Message getPostMessage(Runnable r) {
        //新建一个Message
        Message m = Message.obtain();
        //Runnable 作为Message的一个变量callback 
        m.callback = r;
        return m;
    }
1
2
3
4
5
6
7

public final boolean sendMessageDelayed(Message msg, long delayMillis)
    {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    }
1
2
3
4
5
6
7

可见post(runnable)最终也是调用sendMessageAtTime()来发送消息MessageQueue的。通过上面的代码我们知道runnable 作为Message的一个变量callback 封装到Message中了，那么什么时候回调这个runnable呢？答案是当我们new Handler()时执行Looper.loop()的时候，会执行一句msg.target.dispatchMessage(msg)，其中msg.target即是发送Message的handler，最终处理Message还是这个handler，来看dispatchMessage的源码：

public void dispatchMessage(Message msg) {
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        handleMessage(msg);
    }
  }
1
2
3
4
5
6
7
8
9
10
11
12

private static void handleCallback(Message message) {
        message.callback.run();
    }
1
2
3

如果callback 不为null，则执行handleCallback(msg)，直接回调runnable里的run()方法;如果callback 为null，则执行Handler的handleMessage来处理之前传递到MessageQueue的消息，整个过程：

总结：

1、在子线程中更新UI有多种: Handler发送Message、Handler的post(runnable)方法、View.post()方法、Activity的runOnUiThread()方法
2.Handler的初始化会获取到当前线程的Looper对象，并通过Looper获得对应的MessageQueue对象
3.如果在子线程中使用Handler，必须首先调用Looper.prepare()，如：

new Thread(new Runnable() {
            @Override
            public void run() {
                Looper.prepare();
                //初始化Handler之前必须先调用Looper.prepare()
                Handler handler = new Handler();
                Looper.loop();
            }
        }).start();
1
2
3
4
5
6
7
8
9

4.Handler在当前线程初始化时创建了对应的Looper，Looper初始化时又会创建对应的MessageQueue，一个线程中只有一个Looper和一个MessageQueue，但可以有多个Handler，他们往同一个MessageQueue中发送消息并且Looper从MessageQueue中取出消息后，再交给发送这个Message的Handler去处理。

PS：关于Handler使用可能会内存泄露问题，可以参考这篇文章：Android中Handler引起的内存泄露

参考：
1、Android 中线程间通信原理分析：Looper, MessageQueue, Handler
2、Android异步消息处理机制完全解析，带你从源码的角度彻底理解
3、Android 异步消息处理机制 让你深入理解 Looper、Handler、Message三者关系