从入坑到放弃——Android消息机制

从入坑到放弃是一个系列，讲述的是一个Android开发者在工作和学习时的悲惨命运，也希望读者在看文章 的时候能抱着同情的心情，自备纸巾。有钱的捧个钱场，没钱的借钱捧个钱场并双击666。

下面进入正题，Android消息机制，相信每个android开发者在平时工作中都会经常用到的。Handler是一个耳熟能详的词，也是在工作中需要交互的一个类。消息机制的存在就是为了解决Android系统中子线程中不能更新UI的矛盾，主线程（即UI线程）不能执行耗时的操作，比如经常提到的下载，否则会触发系统的ANR。所以耗时的操作就不得不放到主子线程去执行，如果想把下载的结果体现到View上，又不能直接更新，这时就需要Handler从子线程给主线程发送消息了。先来看一个简单的小“栗子”吧：

xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context="com.transsion.zuochenzhang.testhandler.MainActivity">
    <ProgressBar
        android:id="@+id/progress"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:progress="0"
        android:max="100"
        style="?android:attr/progressBarStyleHorizontal"/>

    <Button
        android:id="@+id/bt"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="模拟进度"
        />    
</LinearLayout>     

MainActivity

public class MainActivity extends AppCompatActivity {

    private ProgressBar progressBar;
    private Button button;
    private int count;

    private Handler handler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            progressBar.setProgress(msg.what);
        }
    };
        @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        progressBar = (ProgressBar)findViewById(R.id.progress);
        button = (Button)findViewById(R.id.bt);
        button.setOnClickListener(new TestProgressBar());

    }

    class TestProgressBar implements View.OnClickListener{

        @Override
        public void onClick(View v) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    Timer timer = new Timer();
                    timer.schedule(new TimerTask() {
                        @Override
                        public void run() {
                            if(count == 100){
                                return;
                            }
                            count = count + 10;
                            Message msg = new Message();
                            msg.what = count;
                            handler.sendMessage(msg);
                        }
                    },0,1000);
                }
            }).start();
        }
    }
}

这里我搞了一个ProgressBar和一个Button，当我点击button的时候，使用计时器模拟了一个下载的动作，每隔一秒就去更新progressBar的进度，0-100每次更新10，这个10 就是通过handler从子线程传递给了主线程，然后更新UI。
在整个消息机制的体系下，是通过Handler，Looper以及MessageQueue它们之间相互协作来完成一整套工作的。首先请欣赏来自灵魂画手的一幅作品

工作原理

ThreadLocal与Looper
首先说一下ThreadLocal不是线程，它是保证线程之间互不干扰的保存数据。理论上在使用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());
            }
        }
        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;
    }

在handler的构造方法当中可以看到，会判断Looper.myLooper是不是空，如果空的话就会抛异常

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

这里能看到looper是从threadlocal中获取出来的，那么肯定会地方会set

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

    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

在looper的prepare方法里看到了set和具体的set实现，这里能看出来在set同时也获取了当前的线程，根据当前线程获取到了一个ThreadLocalMap，这样就能保证不同线程之间保存的数据互不干扰。最后map.set
时候key就是当前的threadlocal对象，values就是要保存的数据，这里指的就是looper对象。所以其实使用handler的正确姿势应该是这样的：

        Looper.prepare();
        Handler handler = new Handler();
        Looper.loop();

可是平时在使用handler的时候为什么没有这么做呢，这时候要去ActivityThread.java中去寻找答案了

    public static void main(String[] args) {
        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
        SamplingProfilerIntegration.start();

        // CloseGuard defaults to true and can be quite spammy.  We
        // disable it here, but selectively enable it later (via
        // StrictMode) on debug builds, but using DropBox, not logs.
        CloseGuard.setEnabled(false);

        Environment.initForCurrentUser();
        ...省略部分
        Looper.prepareMainLooper();
    }

在ActivityThread的main方法中已经准备了一个looper

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

到这里又看到了myLooper方法，那么它自然是从threadlocal中获取出来的，所以在UI线程android系统已经为我们准备了looper。如果是在子线程中，就要老老实实的自己准备looper

MessageQueue
MessageQueue即为消息队列，准备好了looper，looper的作用是不断轮询MessageQueue的，那下面就看下轮询的时候MQ（之后MessageQueue简称为MQ）都做了什么。MQ虽然叫作消息队列，但是它的实现其实是用链表来完成的。因为MQ主要就是两个功能，一个是插入数据，一个是删除数据，那么自然链表在这两个功能上效率是高的。

    boolean enqueueMessage(Message msg, long when) {
        if (msg.target == null) {
            throw new IllegalArgumentException("Message must have a target.");
        }
        if (msg.isInUse()) {
            throw new IllegalStateException(msg + " This message is already in use.");
        }
        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) {
             // New head, wake up the event queue if blocked.
             msg.next = p;
             mMessages = msg;
             needWake = mBlocked;  
         } else {
              // Inserted within the middle of the queue.  Usually we don't have to wake
              // up the event queue unless there is a barrier at the head of the queue
              // and the message is the earliest asynchronous message in the queue.
              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;
            }  
                // We can assume mPtr != 0 because mQuitting is false.
            if (needWake) {
                nativeWake(mPtr);
            }
        }
        return true;
    }                 

enqueueMessage即为消息插入到MQ中的操作

    Message next() {
        // Return here if the message loop has already quit and been disposed.
        // This can happen if the application tries to restart a looper after quit
        // which is not supported.
        final long ptr = mPtr;
        if (ptr == 0) {
            return null;
        }
        int pendingIdleHandlerCount = -1; // -1 only during first iteration
        int nextPollTimeoutMillis = 0;
        for (;;) {
            if (nextPollTimeoutMillis != 0) {
                Binder.flushPendingCommands();
            }  
            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) {
                    // Stalled by a barrier.  Find the next asynchronous message in the queue.
                    do {
                        prevMsg = msg;
                        msg = msg.next;
                    } while (msg != null && !msg.isAsynchronous());
                }
                if (msg != null) {
                    if (now < msg.when) {
                        // Next message is not ready.  Set a timeout to wake up when it is ready.
                        nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                    } else {
                        // Got a message.
                        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 {
                    // No more messages.
                    nextPollTimeoutMillis = -1;
                 }

                // Process the quit message now that all pending messages have been handled.
                if (mQuitting) {
                    dispose();
                    return null;
                } 
            之后的省略...
          }
      }              

next方法里面的for循环是个无限循环，如果有新消息就return消息并从链表中删除此条消息，如果没有就阻塞

工作流程
了解完他们各自的工作原理，最后来梳理一下handler整个的流程。首先Looper.prepare去准备了一个looper，将创建的looper存到了threadlocal当中。然后我们可以创建Handler，在new Handler时候取出了looper，给MQ赋值等，参考最上面的源码。最后执行Loop.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 slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;

            final long traceTag = me.mTraceTag;
            if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
                Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
            }
            final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
            final long end;
            try {
                msg.target.dispatchMessage(msg);
                end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }
            省略之后代码...
          }
        }      

loop方法中，不断循环MQ，判断是否有新消息，如果有最后调用msg.target.dispatchMessage();这里要注意，这句代码就是真正调用发送消息的代码，是在Looper.java里执行的，而不是在Handler.java里，msg.target就是handler对象。当我们执行handler.sendMessage()的时候，MQ中就是有新消息，执行msg.target.dispatchMessage();

    /**
     * Subclasses must implement this to receive messages.
     */
    public void handleMessage(Message msg) {
    }

    /**
     * Handle system messages here.
     */
    public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }

从这里回调了handleMessage(msg)，就可以接受发送的消息，然后处理自己的业务逻辑。再提一句就是无论以哪个方法来放松消息最后都会调用sendMessageAtTime方法来插入到MQ中，如果不相信读者可以自己点一点源码看看

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

以上说的就是Android消息机制的整个一套原理和工作流程，欢迎各位读者大神们多提意见。写的头晕眼花，要去吃饭恢复体能了。