Android的消息机制

概述

Android消息机制主要是指Handler的运行机制以及Handler所附带的MessageQueue和Looper的工作过程。而Handler的主要作用是将一个任务切换到某个指定的线程中去执行。

• Android为什么需要提供在某个线程中执行任务这种功能？
  因为Android规定只能在主线程中进行访问UI，如果子线程中访问UI，那么程序就会抛出异常。在ViewRootImpl对UI操作进行了验证，如下：

void checkThread(){
    if (mThread != Thread.currentThread){
        throw new CalledFromWrongThreadException(
            "Only the original thread that created a view
            hierarchy can touch its views.");
    }
}

其中mThread表示为主线程。

• 为什么系统不允许在子线程中访问UI？
  因为Android的UI控件不是线程安全的，如果在多线程中并发访问可能会导致UI空间不可预期的状态。

• 再谈Handler的作用：
  对于一般耗时的任务通常会在子线程中执行，防止阻塞主线程。任务执行后产生的数据，如果需要将数据传递给UI，进行对UI的修改，那么就需要Handler将数据传递给主线程，通过主线程对UI进行修改。

Handler的使用

Handler主要包含两种使用方法：

• 通过sendMessage方法发送Message，然后在handleMessage方法中获取到Message数据。
• 通过创建一个Runnable，在Runnable中对UI进行更新，并且将Runnable对象提交给Handler执行。

public class MainActivity extends AppCompatActivity {
    private TextView textView1;
    private TextView textView2;
    private Handler handler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what){
                case 0:
                    textView1.setText(msg.obj.toString());
                    break;
            }
        }
    };
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        textView1 = (TextView) findViewById(R.id.text_handler1);
        textView2 = (TextView) findViewById(R.id.text_handler2);
        download1();
        download2();
    }

    private void download1(){
        new Thread(){
            @Override
            public void run() {
                //模拟执行任务
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Message msg = new Message();
                msg.what = 0;
                msg.obj = "任务一下载完成";
                handler.sendMessage(msg);
            }
        }.start();
    }

    private void download2(){
        new Thread(){
            @Override
            public void run() {
                //模拟执行任务
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Runnable runnable = new Runnable() {
                    @Override
                    public void run() {
                        textView2.setText("任务二下载完成");
                    }
                };
                handler.post(runnable);
            }
        }.start();

    }
}

如上为Handler的两种使用方法，在这里要注意的是第一种方法，定义Message时，设置.what来判断消息，设置.obj来传递数据。

Handler的工作原理

Handler创建时会采用当前线程的Looper来构建内部的消息循环系统；创建完毕后，当Handler的send方法被调用或调用post方法提交一个Runnable对象，它会调用MessageQueue的enqueueMessage方法将这个消息放入消息队列中，然后Looper发现有新消息时，就会处理这个消息，最终消息中的Runnable或Handler中的handleMessage方法会被调用。

Handler工作原理.png

消息队列的工作原理

消息队列在Android中表示为MessageQueue，MessageQueue主要包含了两个操作：插入和读取。读取操作本身会伴随着删除操作，插入和读取对应的方法分别为enqueueMessage和next。尽管MessageQueue被称为“消息队列”，但实际上它是通过一个单链表来维护消息列表，因为单链表在插入和删除上有优势。

Looper的工作原理

Looper在消息机制中扮演着消息循环的角色，它会不停地从MessageQueue中查看是否有新消息，如果有新消息，那么会立刻处理，否则会一直阻塞在那。

我们知道Handler的工作需要Looper，没有Looper的线程就会报错，那么如何在一个线程中创建Looper呢？
首先通过Looper.prepare()方法创建一个Looper，然后通过Looper.loop()方法来开启消息循环。

new Thread("test"){
    public void run(){
        Looper.prepare();
        Handler handler = new Handler();
        Looper.loop();
    }
}.start();

也许你会纳闷，为什么我们在之前的使用中创建Handler对象时，并没有调用Looper.prepare()来创建Looper对象呢？
实际上，是因为我们之前的使用时在主线程中创建的Handler对象，而在主线程中，系统已经把我们创建好了Looper对象。

如下，我们在子线程中创建了Handler对象，并接收到另一个子线程传递过来的数据：

public class MainActivity extends AppCompatActivity {
    private Handler handler1 = null;

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

    private void download1(){
        new Thread("Thread#1"){
            @Override
            public void run() {
                Looper.prepare();
                handler1 = new Handler(){
                    @Override
                    public void handleMessage(Message msg) {
                        switch (msg.what){
                            case 0:
                                Log.d("tag","get msg from thread2: " + msg.obj.toString());
                                break;
                        }
                    }
                };
                Looper.loop();
            }
        }.start();
    }

    private void download2(){
        new Thread("Thread#2"){
            @Override
            public void run() {
                //模拟执行任务
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Message msg = new Message();
                msg.what = 0;
                msg.obj = "Thread2下载任务完成";
                handler1.sendMessage(msg);
            }
        }.start();

    }
}