LJ的Blog

学海无涯苦做舟

0%

Android消息机制浅析

发表于 更新于 分类于

写在前面：

如果你在看本文之前没有对Android消息机制作过了解，可能会比较吃力，关于源码，不需要全部看懂，能看懂其中关键的几句代码就行了。如果在阅读过程中感到吃力，请直接跳到结尾部分看概述。

最近在看《Android开发艺术探索》，感觉真的是一本好书，恩，让我非常有读完欲望的一本书。话不多说，分享一下我的读书收获。

Android中的耗时操作需要在子线程中完成，当这些操作完成后可能会需要对UI进行相应的更新。但是Android中的UI不是线程安全的，在多线程中并发访问可能会导致UI控件处于不可预期的状态。Google没有用上锁机制来解决这个问题，而是让开发者通过Handler切换线程来达到更新UI的目的。Handler是Android消息机制的上层接口，想要解析Android消息机制还需要了解Looper和**消息队列(MessageQueue)**。

在具体的了解Handler、Looper和MessageQueue之前，先让我们把我们平时切换线程的流程过一遍。首先我们在主线程中创建Handler，然后在子线程中通过handler的sendMessage方法将携带子线程操作结果的数据传出，通过handler的handleMessage方法进行UI的更新，代码如下：

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
public class MainActivity extends AppCompatActivity {
    //注1
    private Handler handler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            tvContent.setText((String)msg.obj);
        }
    };
    private TextView tvContent;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        tvContent = (TextView) findViewById(R.id.tv_content);

        new Thread(new Runnable() {
            @Override
            public void run() {
                //...一些耗时操作

                //耗时操作的结果
                String result = "我是结果";

                Message msg = Message.obtain();
                msg.obj = result;
                handler.sendMessage(msg);
            }
        }).start();
    }
}

注1：这篇算是挺久之前的文了吧，现在看来有一个比较致命的东西，private Handler handler;这个东西是一个内部类，在Java中内部类都会隐含的持有一个外部类的引用，一般来说这个外部类的引用就是Activity。如果因为Handler持有了Activity的引用而导致Activity无法被销毁，则会导致内存泄露，解决方法就是用static修饰，static修饰的内部类不会持有外部类的引用。但是很快你就会发现因为他是静态的，所以无法使用外部类的成员了，这对我们更新UI又是个阻碍，你可以考虑采用SoftReference的技术，在Handler内部持有一个activity的软引用，在软引用不为空的情况下通过这个弱引用去访问外部类的成员。

因为代码比较简单，就不上结果图了。接下来解析一下以上简单的代码。

1
2
3
4
5
6
private Handler handler = new Handler(){
    @Override
    public void handleMessage(Message msg) {
        tvContent.setText((String)msg.obj);
    }
};

首先是构造一个Handler对象，用的是默认的构造方法，看一下源码是如何实例化的

1
2
3
public Handler() {
    this(null, false);
}

再追踪一下源码，发现最终是用的如下的构造方法

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

说实话大部分代码我也是看不懂的，但是mLooper = Looper.myLooper()和mQueue = mLooper.mQueue，可以看出Handler得到了一个Looper和一个“队列”。查看myLooper方法的注释

1
2
3
4
/**
* Return the Looper object associated with the current thread.  Returns 
* null if the calling thread is not associated with a Looper.
 */

返回的是当前线程的Looper，如果当前线程没有Looper就返回null。所以在Handler的构造方法中，会有

1
2
3
4
 if (mLooper == null) {
    throw new RuntimeException(
        "Can't create handler inside thread that has not called Looper.prepare()");
}

所以在没有Looper的线程中创建Handler对象会抛以上异常。我们可以为没有Looper的线程创建一个Looper不过这里先不谈。看完了如何创建Handler之后，继续我们的流程，在子线程中我们使用handler的sendMessage()方法发送了一个Message对象，让我们看看这背后隐藏了怎样的py交……，不，怎样的操作。

1
2
3
4
public final boolean sendMessage(Message msg)
{
    return sendMessageDelayed(msg, 0);
}

通过追踪源码发现最终执行了如下代码：

1
2
3
4
5
6
7
8
9
10
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);
}

最后一句代码是向queue中插入msg的意思，也就是说handler.sendMessage()这个方法所执行的操作就是向消息队列插入了一条message，那么这条消息又是经历了怎样的辗转才切换到了当前线程呢？显然这其中有Looper的参与,不过在了解Looper之前，需要先了解一下MessageQueue。

#MessageQueue#
MessageQueue虽然叫消息队列，但实际上他是通过一个单链表的数据结构来维护消息列表。至于为什么采用单链表的数据结构，因为MessageQueue主要操作是插入和读取，而读取包含着删除操作，而单链表在插入和删除上比较有优势。关于MessageQueue还需要知道enqueueMessage()是插入操作，next()是读取并且删除的操作。需要了解的暂时就这么多了。

Looper

Looper会不停地从MessageQueue中查看是否有新消息，如果有新消息就会立刻处理，否则就一直阻塞在那里。Looper最重要的方法便是loop()方法，让我们看一下loop()方法是怎样的:

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
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
        Printer logging = me.mLogging;
        if (logging != null) {
            logging.println(">>>>> Dispatching to " + msg.target + " " +
                    msg.callback + ": " + msg.what);
        }

        msg.target.dispatchMessage(msg);

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

如果MessageQueue的next方法返回了新的消息，Looper就会处理这条消息

1
msg.target.dispatchMessage(msg);

msg.target就是发送这条消息的Handler对象，这样Handler发送的消息最终又交给它的dispatchMessage方法来处理了。查看dispatchMessage方法源码会发现，我们之前使用的Handler的构造方法和得到Message对象的方法，最终会导致dispatchMessage方法调用handleMessage方法。

总结与拓展

总的来说，我们平常使用Handler所经历的流程就是：
１.使用当前线程的Looper对象创建Handler。
２.handler.sendMessage()向Looper中的消息队列插入消息。
３.Looper通过loop方法获取消息队列的新消息，通过msg.target(发送消息的Handler)调用dispatchMessage方法处理消息。而该方法在loop方法中被调用，loop被当前线程Looper调用，所以该消息被切换到当前线程中执行。

流程.png

　　在了解了Android的消息机制之后，我们可以尝试使用Handler和Looper实现两个子线程之间的消息传递。通过new Thread()创建的线程并没有Looper，为他创建一个Looper就可以使用Handler了。Looper可以通过prepare方法来创建，好了说明就到这，直接上代码！

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
52
53
54
55
56
57
58
59
60
61
62
63
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;

public class MainActivity extends AppCompatActivity {

    private final String TAG = "MainActivity";
    private Handler mhandler;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Thread1 thread1 = new Thread1();
        thread1.setName("Thread#1");
        thread1.start();

        mhandler = thread1.getHandler();
        while(mhandler == null){
            mhandler = thread1.getHandler();
        }

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    Message msg = Message.obtain();
                    msg.obj = System.currentTimeMillis();
                    mhandler.sendMessage(msg);
                }
            }
        }, "Thread#2").start();


    }


    class Thread1 extends Thread {
        private Handler mhandler;

        public Handler getHandler() {
            return mhandler;
        }

        @Override
        public void run() {
            //为该线程创建Looper
            Looper.prepare();
            //初始化handler
            mhandler = new Handler() {
                @Override
                public void handleMessage(Message msg) {
                    Log.i(TAG, Thread.currentThread().getName() + " the message is:" + msg.obj);
                }
            };
            Looper.loop();
        }
    }

}

输出结果.png

很明显,Thread#2成功地将消息传递到了Thread#1的handler中。其实关于Looper.prepare()也值得深究，涉及到了ThreadLocal，不过我这里就不管了。
　　
最后再安排一下今后一段时间内要做的事，从第一篇简书文章到这第二篇，中间隔了很久了。倒是没有偷懒，一直在敲代码，不过最近算是把一直想做的东西做了，是时候来一波学习总结了。

资料来源：《Android开发艺术探索》