Android 消息传递机制分析

Android中采用Handle进行消息传递，本文从实例出发分析Handle中一个Message从创建到处理整个流程，以此阐明消息传递机制原理。
一、Handle使用示例
1、在Android studio 创建一个默认项目，在MainActivity中写下如下代码：

public class MainActivity extends AppCompatActivity {
    private TextView tv;
    private final static int MSGTYPE =1;

    //主线程中创建Handle，并重写Handle处理消息的方法handleMessage()
    //我这里只是简单处理更新一个textview显示
    Handler mHandle = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what){
                case MSGTYPE:
                    if(tv !=null){
                        tv.setText(String.valueOf(msg.obj));
                        Log.d("Handle",String.valueOf(msg.obj));
                    }
                    break;
            }
            super.handleMessage(msg);
        }
    };
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        tv = (TextView) findViewById(R.id.tv);
            new Thread(){
                @Override
                public void run() {
                    try {
                        for(int i= 0 ; i<10; i++) {
                            Thread.sleep(1000);
                            //耗时操作在子线程完成，建立一个消息
                            //实体，并携带数据
                            Message msg = new Message();
                            msg.what = MSGTYPE;
                            msg.obj = "Thread" + i;
                            //通过Handle发送消息
                            mHandle.sendMessage(msg);
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
            }.start();
   }
}

子线程通过handle发消息给主线程（UI线程）然后在主线程handle中处理消息，来达到更新UI目的。那么问题来了在这里我们为什么不直接在主线程更新UI或者直接在子线程调用tv.setText()？不在主线程更新是因为主线程不能进行耗时操作，假设一种场景tv控件的数据来源于网络，需要建立一个http获取数据，网络操作是一种极其耗时操作，要等几秒才能更新UI，这对用户体验来说极其不好，而且Android规定UI线程5s没反应，会报ANR错误，所以耗时操作都放子线程。而由于主线程不是线程安全的，Android规定子线程不能更新UI元素。
二、Handle原理分析
在这里我们从上述demo中mHandle.sendMessage(msg)这句代码作为切入口，分析这个msg经过哪些流程被送到mHandle.handleMessage(msg)中进行处理的。
进入Handle.java

//Handler构造函数
public Handler() {
//调用下面含有2个参数的构造函数
        this(null, false);
    }
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());
            }
        }
        /**
        *Handler类含有2个成员变量，一个looper对象，一个messageQueue对象，在实例化Handle时个2个成员初始化赋值
         *Looper.myLooper()方法返回当前线程looper对象引用，在后面分析Looper对象时再来分析这个方法实现。
        */
        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
        }
       //初始化消息队列，Looper类负责初始化消息队列
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }


public final boolean sendMessage(Message msg)
    {
        return sendMessageDelayed(msg, 0);
    }
public final boolean sendMessageDelayed(Message msg, long delayMillis)
    {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    }
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
        //Handle类持有MessageQueue引用
        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) {
        //target类型是Handle，target保存有发送此消息handler引用，代表这个消息最终由哪个handler来处理
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }

可以发现，Handle发送的msg被添加进消息队列中，然而我们说这个队列是在Looper轮询器初始化的，我们先来看看Looper
进入Looper.java
Looper主要作用是从自己的消息队列中不断的拿出消息，并且分发给对应的handler处理

Looper对象的初始化

public static void prepare() {
        prepare(true);
    }

    private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        /**
        * 看到没下面这句才是真正实例化一个Looper对象
        * 这里调用ThreadLocal类的set方法来保存looper引用
        * 简单说下这个ThreadLocal类，这个类的主要线程的一个成员变量，用来存储线程的
        * 私有数据，主要有2个方法，一个set()，一个get();
        * 不懂同学可以看一看ThreadLocal原理
        */
        sThreadLocal.set(new Looper(quitAllowed));
    }
    //实例化Looper时，会在构造方法实例化一个MessageQueue对象，用来存储消息
    private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    }

    /**
     * 这个方法是在主线程调用，用来在主线程中初始化looper
     * 其实我们看还是调用prepare()方法
     */
    public static void prepareMainLooper() {
        prepare(false);
        synchronized (Looper.class) {
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            sMainLooper = myLooper();
        }
    }

    public static @Nullable Looper myLooper() {
        /**
        * 看到没,ThreadLocal.get()返回了当前线程looper对象
        *这个和前面Handler调用myLooper()返回looper引用对应
        */
        return sThreadLocal.get();
    }

我们再来看看APP主线程ActivityThread类，是如何初始化looper轮询器的,当我们启动一个APP时，主线程ActivityThread类会被执行，从mian()函数开始

public static void main(String[] args) {
       ......
        /**
        * 主线程初始化looper轮询器,我们在主线程中实例化Handler对象就是
        * 绑定这个looper，而为什么没有传递looper引用
        * 是因为中间有个ThreadLocal
        */
        Looper.prepareMainLooper();

        ActivityThread thread = new ActivityThread();
        thread.attach(false);

        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }

        if (false) {
            Looper.myLooper().setMessageLogging(new
                    LogPrinter(Log.DEBUG, "ActivityThread"));
        }

        // 开启loop死循环，不断轮训消息队列
        Looper.loop();

        throw new RuntimeException("Main thread loop unexpectedly exited");
    }
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 (;;) {
            //next()从队列拿消息，当next()返回为null时，则在这里阻塞，等待唤醒后继续执行
            Message msg = queue.next();  
            if (msg == null) {
                // 如果没有消息，表明消息队列正在退出
                return;
            }

            try {
                //消息不为空，调用target对象dispatchMessage(),在发送msg时，msg的
                //target就保存了发送消息的handle对象，此时这个msg就送到处理消息的
                //handle中
                msg.target.dispatchMessage(msg);
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }

        .....

        }
    }
//消息分发
public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            //handleMessage(msg)被我们重载实现
            handleMessage(msg);
        }
    }

至此我们进入MessageQueue.java
MessageQueue有2个主要方法一个是消息入队enqueueMessage()。一个是消息出对next()

boolean enqueueMessage(Message msg, long when) {
        ....
        synchronized (this) {
            if (mQuitting) {
                IllegalStateException e = new IllegalStateException(
                        msg.target + " sending message to a Handler on a dead thread");
                Log.w(TAG, e.getMessage(), e);
                msg.recycle();
                return false;
            }

            msg.markInUse();
            msg.when = when;
            Message p = mMessages;
            boolean needWake;
            if (p == null || when == 0 || when < p.when) {
                //当入队消息是第一个时，如果loop（）阻塞,则要唤醒loop线程
                msg.next = p;
                mMessages = msg;
                needWake = mBlocked;
            } else {

                needWake = mBlocked && p.target == null && msg.isAsynchronous();
                Message prev;
                for (;;) {
                    prev = p;
                    p = p.next;
                    if (p == null || when < p.when) {
                        break;
                    }
                    if (needWake && p.isAsynchronous()) {
                        needWake = false;
                    }
                }
                msg.next = p; // invariant: p == prev.next
                prev.next = msg;
            }

            if (needWake) {
                //唤醒主线程,这里用到了jni编程，这这里不展开讲
                nativeWake(mPtr);
            }
        }
        return true;
    }

enqueueMessage()这个方法是把消息加入消息队列，中间有一些if-else判断，当队列为空，主线程空闲等待，有消息加入时则唤醒主线程。
    Message next() {
        // 从队列中取消息

        final long ptr = mPtr;
        if (ptr == 0) {
            return null;
        }

        int pendingIdleHandlerCount = -1; 
        int nextPollTimeoutMillis = 0;
        for (;;) {
            if (nextPollTimeoutMillis != 0) {
                Binder.flushPendingCommands();
            }
            //jni方法，功能是查看当前消息队列是否有消息，没有则等待，有则获取
            nativePollOnce(ptr, nextPollTimeoutMillis);

            synchronized (this) {
                // Try to retrieve the next message.  Return if found.
                final long now = SystemClock.uptimeMillis();
                Message prevMsg = null;
                Message msg = mMessages;
                if (msg != null && msg.target == null) {

                    do {
                        prevMsg = msg;
                        msg = msg.next;
                    } while (msg != null && !msg.isAsynchronous());
                }
                if (msg != null) {
                    if (now < msg.when) {
                        // 判断消息时间，没有到，则等待
                        nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                    } else {
                        // 取消息
                        mBlocked = false;
                        if (prevMsg != null) {
                            prevMsg.next = msg.next;
                        } else {
                            mMessages = msg.next;
                        }
                        msg.next = null;
                        if (DEBUG) Log.v(TAG, "Returning message: " + msg);
                        msg.markInUse();
                        return msg;
                    }
                } else {
                    //没有消息，则阻塞等待
                    nextPollTimeoutMillis = -1;
                }
}

通过UML绘制Handle、Message、MessageQueue、Looper之间关系

至此，一个消息完成整个流程。
欢迎大家对文章提出评论。