一天一Android之异步消息处理机制

无论是Android还是iOS，关于UI的操作都是线程不安全的，所有的UI操作只能在主线程中执行。有时候我们会在子线程中做一些耗时的操作，比如网络资源的请求，当这些耗时操作结束时，我们又希望拿这些请求下来的资源去更新UI，但是当前线程为子线程，而更新UI由必须在主线程中，这就涉及到了线程间的通信问题。

学过iOS的同学都知道，我们可以使用GCD或者performSelectorOnMainThread:等技术来达到我们的需求。而在Android中，我们就要使用到异步消息处理机制了。

这篇文章就来详细说一下异步消息处理机制。

线程间通信常用的解决方案

runOnUiThread

通常情况下，使用runOnUiThread这种方式回到主线程是最为方便，代码量也比较少，具体的使用方式为：

private void requestData() {
    new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                //子线程模拟耗时操作
                Thread.sleep(3000);
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        //主线程更新UI
                    }
                });
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }).start();
}

因为这种方式使用简单，这里我们不再细说。

Handler

我们先来看看如何使用Handler

public class MainActivity extends AppCompatActivity {
    
    private Handler mHandler;
    private TextView mTextView;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mTextView = (TextView) findViewById(R.id.textView);
        Button onUIButton = (Button) findViewById(R.id.button);
        onUIButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                requestData();
            }
        });
        //在主线程中创建Handler
        mHandler = new Handler(new Handler.Callback() {
            @Override
            public boolean handleMessage(Message msg) {
                //接受到消息
                String str = (String) msg.obj;
                mTextView.setText(str);
                return false;
            }
        });
    }
    private void requestData() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    //子线程模拟耗时操作
                    Thread.sleep(3000);
                    Message message = new Message();
                    message.obj = "消息";
                    //handler发送消息
                    mHandler.sendMessage(message);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

首先在主线程中创建Handler，在requestData方法中，开启一个子线程，子线程中模拟耗时操作，操作结束后，使用Handler发送消息，在主线程中接收到消息，更新UI。

这种方式在开发中使用的最频繁，至于其中的原理，我们慢慢来探究。

Handler原理剖析

上面的例子中，我们创建Handler是在主线程中创建，可能你会想了，我在子线程中创建行么？我们来用代码实验一下。

public class MainActivity extends Activity {  
      
    private Handler handler1;  
      
    private Handler handler2;  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
        handler1 = new Handler();  
        new Thread(new Runnable() {  
            @Override  
            public void run() {  
                handler2 = new Handler();  
            }  
        }).start();  
    }  
}

在上段代码中，我们在主线程中创建handler1，在子线程中创建handler2。当是，当我们允许程序的时候，程序竟然崩溃了，错误提示信息是Can’t create handler inside thread that has not called Looper.prepare()。说是不能再没有调用Looper.prepare()的线程中创建Handler。那系统既然这么说了，那么我们就在子线程中添加这句代码。

new Thread(new Runnable() {  
    @Override  
    public void run() {  
        Looper.prepare();  
        handler2 = new Handler();  
    }  
}).start();

果然不会崩溃了，为什么呢？

Handler与Looper的关系

为什么在子线程中创建Handler会崩溃呢？

我们先来看看Handler的有参和无参构造方法:

public Handler() {
    this(null, false);
}
public Handler(Callback callback) {
    this(callback, false);
}

发现他们都调用了public Handler(Callback callback, boolean async)这个方法，来看看这个方法的具体实现：

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()方法获取一个Looper对象，如果Looper对象为空，就会抛异常，那什么时候Looper对象为空呢？我们再来看看Looper.myLooper()中的代码。

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

这个方法很简单，就是从sThreadLocal对象中取出Looper，如果sThreadLocal中有Looper存在就返回Looper，否则返回空。那么我们在什么时候给sThreadLocal设置Looper呢？经验得出，肯定是Looper.prepare()，因为我们没有调用这个方法的时候，程序会崩溃。😄

我们来看Looper.prepare()方法的源码：

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");
    }
    sThreadLocal.set(new Looper(quitAllowed));
}

可以看到，prepare方法又调用了prepare(boolean quitAllowed)方法，我们直接看prepare(boolean quitAllowed)方法。

首先判断sThreadLocal中是否已经存在Looper了，如果不存在，创建一个新的额Looper并设置给sThreadLocal。这就解释了，我们创建Handler的时候，为什么必须先调用Looper.prepare()方法。如果已经存在，会抛异常。由此得出，一个线程中只能存在一个Looper。

可能你还会疑惑，我们在主线程创建Handler到时候并没有去调用Looper.prepare()方法，程序也没有崩溃啊。这是因为在程序启动的时候，系统已经帮我们自动调用了Looper.prepare()方法。看ActivityThread中的main()方法。

public static void main(String[] args) {  
    SamplingProfilerIntegration.start();  
    CloseGuard.setEnabled(false);  
    Environment.initForCurrentUser();  
    EventLogger.setReporter(new EventLoggingReporter());  
    Process.setArgV0("<pre-initialized>");  
    Looper.prepareMainLooper();  
    ActivityThread thread = new ActivityThread();  
    thread.attach(false);  
    if (sMainThreadHandler == null) {  
        sMainThreadHandler = thread.getHandler();  
    }  
    AsyncTask.init();  
    if (false) {  
        Looper.myLooper().setMessageLogging(new LogPrinter(Log.DEBUG, "ActivityThread"));  
    }  
    Looper.loop();  
    throw new RuntimeException("Main thread loop unexpectedly exited");  
}

可以看到，系统帮我们调用了Looper.prepareMainLooper()方法，而这个方法又会再去调用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();
    }
}

因此我们的应用程序的主线程中始终存在一个Looper对象，从而不需要再动手去调用Looper.prepare()。

这样关于Handler和Looper的关系就很明确了，Handler的创建依赖与Looper。一个线程中至多有一个Handler。

Handler、Message、Looper的消息机制

我们已经明白了Handler和Looper之间的大概关系，那么这三者之间的具体是如何协同操作的呢？

我们先来看看Handler是如何发送消息的:

new Thread(new Runnable() {  
    @Override  
    public void run() {  
        Message message = new Message();  
        message.arg1 = 1;  
        Bundle bundle = new Bundle();  
        bundle.putString("data", "data");  
        message.setData(bundle);  
        handler.sendMessage(message);  
    }  
}).start();

其实Message只是一个载体，它可以使用setData()或arg参数等方法来携带一些数据，然后通过Handler将消息发送出去。

那么Handler把Message发送到哪里了呢？而且我们又可以在Handler的handleMessage()方法中重新得到这条Message呢？我们来看Handler的sendMessage方法：

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

我们看到，辗转反则最后调用了sendMessageAtTime，在此方法的内部，又调用了enqueueMessage方法，此方法接收三个参数：第一个参数queue就是一个消息队列，它将所有收到的消息以队列的形式进行排列，并提供入队和出队的操作，其实当前Handler中的queue是由Looper创建的，Handler只是引用了此queue，我们查看Handler的构造方法，里面会有这样两句代码:

public Handler(Callback callback, boolean async) {
	...
	mLooper = Looper.myLooper();
	...
	mQueue = mLooper.mQueue;
	...
}

因此，一个Looper也就只有一个MessageQueue。第二个参数msg就是我们所要发送的消息Message，第三个参数uptimeMillis则表示发送消息的时间，它的值等于系统开机到当前时间的毫秒数再加上延迟时间，如果我们调用的不是endMessageDelayed()方法，延迟时间就是0。然后我们再来看调用的enqueueMessage方法的实现：

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
    msg.target = this;
    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis);
}

此方法会把当前Handler设置为msg的target，这个target的作用我们等会再说。然后就是调用消息队列的enqueueMessage方法，毫无疑问，就是把消息入队了。我们看源码：

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

首先判断msg的target是否为空，如果为空抛异常，由此我们看出target在后面会有大作用。其次判断此消息是否已经加入到队列中去。然后设置msg为已加入标记，msg触发时间，这里会取出之前的消息，首先你要知道，MessageQueue并没有使用一个集合把所有的消息都保存起来，它只使用了一个Messages对象表示当前待处理的消息，而且每个Messages对象都会有一个next字段，它也是一个Messages对象，由此可以组成类似于链表一样的数据结构。而且这里会判断当前msg的触发时间是不是0，如果是0直接加入到链表的头部。如果msg的触发时间不是0，会一直循环遍历当前MessageQueue对象中的消息链表，并比较触发时间，重新排列消息链表。如此，当前消息已经被插入到整个消息队列中。

我们会疑惑，代码到这里已经没有了，但是Handler又是如何接收到消息的呢？

不知道大家注意没，我们在看ActivityThread中的main()方法中，有没有还看到这样一句代码：Looper.loop()，这句代码会不会和我们的消息队列有关系呢？我们先来做个试验：我们在子线程中创建一个Handler，并且发送一条消息，但是我们只调用Looper.prepare()方法，我们是否能接收到消息：

private void requestData() {
    new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                Looper.prepare();
                Handler handler = new Handler(new Handler.Callback() {
                    @Override
                    public boolean handleMessage(Message msg) {
                    	//标记一下接受到消息
                        Log.d("msg","接收到消息");
                        return false;
                    }
                });
                //子线程模拟耗时操作
                Thread.sleep(3000);
				   //发送消息
                handler.sendMessage(new Message());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }).start();
}

运行程序以后，在控制台并没有看到打印的信息，然后我们在handler.sendMessage(new Message())后面添加Looper.loop()代码，再次运行，我们可以看到控制台有信息打印，注意，Looper.loop()会造成代码阻塞，必须放在代码的最后面。由此我们可以确信，消息的发送确实和Looper.loop()方法有很大关系，我们看源码：

public static void loop() {
	 //获取当前线程的Looper
    final Looper me = myLooper();
    if (me == null) {
        //如果当前线程没有Looper 抛出异常    
        throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
    }
    //拿到当前Looper的消息队列
    final MessageQueue queue = me.mQueue;
	
    Binder.clearCallingIdentity();
    final long ident = Binder.clearCallingIdentity();
    
	 //死循环当前消息队列
    for (;;) {
        Message msg = queue.next(); // might block
        if (msg == null) {
        	//没有消息返回
           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.isTagEnabled(traceTag)) {
            Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
        }
        try {
        	  //拿到消息之前存储的target也就是Handler 发送消息
            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();
    }
}

可以看到，首先会判断当前线程是否有Looper，如果没有抛出异常，所以Looper.loop()一定要在Looper.prepare()方法之后，然后拿到当前Looper的消息队列mQueue，之后进入无限循环，取出第一条消息，如果没有消息则阻塞，如果我们使用Handler发送消息，这个时候则能通过循环取到消息，之后调用消息的target的dispatchMessage()方法来回调消息信息。其实消息的target就是Handler。

再来看看Handler的dispatchMessage()方法。

public void dispatchMessage(Message msg) {  
    if (msg.callback != null) { 
    	 //使用Handler的post方法发送消息会走这里 
        handleCallback(msg);  
    } else {  
        if (mCallback != null) {  
        	  //使用Handler的sendMessage方法会走这里
            if (mCallback.handleMessage(msg)) {  
                return;  
            }  
        }  
        handleMessage(msg);  
    }  
}

我们在使用Handler的有参构造函数的时候，会传一个Callback对象，他是一个接口，只有一个方法handleMessage()，所以会再次走我们的回调函数，传递消息。

至此，关于Looper、Handler、Message这三者关系我们已经非常清楚了，来张图解释一下：

另外除了还有一种发送消息的方法：Handler的post()方法。

先来看看post()方法的实现：

public final boolean post(Runnable r)
{
   return  sendMessageDelayed(getPostMessage(r), 0);
}

原来这里还是调用了sendMessageDelayed()方法去发送一条消息啊，并且还使用了getPostMessage()方法将Runnable对象转换成了一条消息，我们来看下这个方法的源码：

private static Message getPostMessage(Runnable r) {
    Message m = Message.obtain();
    m.callback = r;
    return m;
}

在这个方法中将消息的callback字段的值指定为传入的Runnable对象。咦？这个callback字段看起来有些眼熟啊，喔！在Handler的dispatchMessage()方法中原来有做一个检查，如果Message的callback等于null才会去调用handleMessage()方法，否则就调用handleCallback()方法。那我们快来看下handleCallback()方法中的代码吧：

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

也太简单了！竟然就是直接调用了一开始传入的Runnable对象的run()方法。因此在子线程中通过Handler的post()方法进行UI操作就可以这么写：

public class MainActivity extends Activity {  
  
    private Handler handler;  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
        handler = new Handler();  
        new Thread(new Runnable() {  
            @Override  
            public void run() {  
                handler.post(new Runnable() {  
                    @Override  
                    public void run() {  
                        // 在这里进行UI操作  
                    }  
                });  
            }  
        }).start();  
    }  
}

虽然写法上相差很多，但是原理是完全一样的，我们在Runnable对象的run()方法里更新UI，效果完全等同于在handleMessage()方法中更新UI。

通过以上所有源码的分析，我们已经发现了，不管是使用哪种方法在子线程中更新UI，其实背后的原理都是相同的，必须都要借助异步消息处理的机制来实现，而我们又已经将这个机制的流程完全搞明白了。真好。

一天一Android之异步消息处理机制

线程间通信常用的解决方案

runOnUiThread

Handler

Handler原理剖析

Handler与Looper的关系

Handler、Message、Looper的消息机制

分享到微信朋友圈

分享到微信朋友圈

分享到微信朋友圈

贵永冬

一天一Android之异步消息处理机制

线程间通信常用的解决方案

runOnUiThread

Handler

Handler原理剖析

Handler与Looper的关系

Handler、Message、Looper的消息机制

分享到微信朋友圈

分享到微信朋友圈

分享到微信朋友圈

贵永冬

初识ReactiveCocoa

深入ReactiveCocoa

ReactiveCocoa和RXSwift速查表

关于RAC的一些资料

RunLoop总结

聊一聊GCD的那些事

聊一聊NSOperation的那些事

iOS动画篇之UIView动画

iOS动画篇之CoreAnimation动画

iOS动画之CATransition动画