大话Android多线程(三) 线程间的通信机制之Handler

版权声明：本文为博主原创文章，未经博主允许不得转载
源码：github.com/AnliaLee
大家要是看到有错误的地方或者有啥好的建议，欢迎留言评论

前言

在Android中规定了修改UI控件，更新视图这些操作必须在UI线程（主线程）中进行。而一些耗时的操作例如加载网络数据，查询本地文件、数据等，则必须放到子线程中。因此我们需要一种通信机制使得子线程完成任务后可以通知UI线程更新界面。本章将挑选线程通信机制中的Handler进行讲解，聊一聊它和ThreadLocal、Message、MessageQueue以及Looper之间的故事

ps：本篇博客主要是起到一个引导的作用，帮助大家梳理清楚Handler、Looper、MessageQueue等角色的关系，以及它们在Handler消息机制下所起到的作用，并不会过多地深入到源码中。至于源码的讲解，网上优秀的文章实在是太多了，这里推荐几位前辈撰写的博客，大家可以相互对照着看看

• Android进阶——Android消息机制之Looper、Handler、MessageQueue
• Android 异步消息处理机制 让你深入理解 Looper、Handler、Message三者关系
• Android开发——Android的消息机制详解

ps2：看完这篇博客再去了解源码有助于消化知识哦~

往期回顾
大话Android多线程(一) Thread和Runnable的联系和区别
大话Android多线程(二) synchronized使用解析

子线程向主线程发送消息

在遥远的Android大陆中，U国（UI线程，即主线程）和T国（Thread，子线程）之间发生了战争。某日，U国部队准备攻打T国的首都R城，只要收到地下组织（Handler）的特工小h（Handler的实例）的信号后，即可采取相应的行动（更新UI）。由于R城戒备森严，小h传达信号需要做到格外隐秘，因此制定了如下计划，计划由小h和他专属的情报员小L（Looper，Handler在创建时就会关联一个Looper对象，而Looper存放在ThreadLocal中，每一个线程都会维护自己的Looper，这里的Looper自然是属于主线程的）执行：

• 小h在执行潜入任务前留有各种特定信号的说明，组织可根据说明采取相应的行动

创建Handler实例时，重写handleMessage方法（在其中编写更新UI的操作），以便在消息分配后执行

public class HandlerTestActivity extends AppCompatActivity {
    TextView textShow;

    private static final int CODE_TEST_ONE = 101;
    private static final int CODE_TEST_TWO = 102;
    private static final int CODE_TEST_THREE = 103;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_handler_test);
        textShow = (TextView) findViewById(R.id.text_show);
    }

    private Handler handler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what){
                case CODE_TEST_ONE:
                    textShow.setText("开始刺探军情...");
                    break;
                case CODE_TEST_TWO:
                    textShow.setText("情报收集完毕...");
                    break;
                case CODE_TEST_THREE:
                    textShow.setText("发起总攻！");
                    break;
            }
        }
    };
}

• 小h潜入城中后，只要时机成熟，就会将信号写在纸条（Message，即消息）上塞到小L在城墙上挖好的小洞（MessageQueue）中，见下图（灵魂画手）

MessageQueue：通过单链表的数据结构来存储消息列表，消息按照先进先出的原则进行存取，在线程中创建一个Looper实例时，会自动创建一个与之配对的MessageQueue

我们在子线程中使用Handler实例发送消息时，Handler会调用内部方法enqueueMessage将Message插入到MessageQueue中（Handler.enqueueMessage方法最后调用了MessageQueue.enqueueMessage方法存放Message，有关Handler发送消息的方法请见下文附录一）

public class HandlerTestActivity extends AppCompatActivity {
	//省略部分代码...
    public void clickEvent(View view) {
    	switch (view.getId()) {
            case R.id.btn_start:
                new Thread(new TestRunnable()).start();
                break;
    	}
    }

    private class TestRunnable implements Runnable{
        @Override
        public void run() {
            try {
                handler.sendEmptyMessage(CODE_TEST_ONE);

//                你也可以这样发送消息
//                Message message = Message.obtain();
//                message.what = CODE_TEST_ONE;
//                handler.sendMessage(message);

//                或者
//                message.sendToTarget();

                Thread.sleep(2000);
                handler.sendEmptyMessage(CODE_TEST_TWO);

                Thread.sleep(2000);
                handler.sendEmptyMessage(CODE_TEST_THREE);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

• 城外负责接应的小L会一直蹲守在小洞旁（Looper.loop），一旦发现洞中出现纸条（MessageQueue.next），就将其取出送回组织（Handler.dispatchMessage），然后返回继续蹲守小洞

Looper.loop方法不断地调用MessageQueue.next方法读取消息，若消息不为空则调用Handler.dispatchMessage方法将消息分发出去

• 组织拿到纸条后，首先确定纸条是不是由小h发出的，确认无误后，根据纸条上的信号采取相应行动

之前在Looper中调用了Handler的dispatchMessage方法，而在dispatchMessage方法中又调用了Handler.handleMessage方法，这样就回到了我们第一点重写的代码，实现了从子线程中发送消息到主线程更新UI的操作

最后运行效果如图所示

总结Handler创建，发送消息到处理消息的整个流程，大致如下图所示

主线程向子线程发送消息

主线程的Looper在应用开启前系统就已经帮我们创建好了，如果我们要在主线程中向子线程发送消息，则需要在子线程创建时手动创建Looper并开启循环，具体实现代码如下：

public class HandlerTestActivity extends AppCompatActivity {
    private Handler handler2;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_handler_test);
        TestThread testThread = new TestThread();
        testThread.start();

        while (true){//保证testThread.looper已经初始化
            if(testThread.looper!=null){
                handler2 = new Handler(testThread.looper){
                    @Override
                    public void handleMessage(Message msg) {//子线程收到消息后执行
                        switch (msg.what){
                            case CODE_TEST_FOUR:
                                Log.e(TAG,"收到主线程发送的消息");
                                break;
                        }
                    }
                };

                handler2.sendEmptyMessage(CODE_TEST_FOUR);//在主线程中发送消息
                break;
            }
        }

    private class TestThread extends Thread{
        private Looper looper;

        @Override
        public void run() {
            super.run();
            Looper.prepare();//创建该子线程的Looper实例
            looper = Looper.myLooper();//取出该子线程的Looper实例
            Looper.loop();//开始循环
        }
    }
}

当然上面的代码只是简单地体验一下手动创建Looper的过程，实际上系统已经为我们封装好了HandlerThread类，它帮助我们完成了创建Looper、开启循环等一系列操作，因此使用HandlerThread会更加方便和安全。以上述同样的操作为例，这次我们直接继承HandlerThread创建子线程：

public class HandlerTestActivity extends AppCompatActivity {
    private HandlerThread handlerThread;
    private Handler handler2;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_handler_test);
		
        handlerThread = new HandlerThread("MyHandlerThread");
        handlerThread.start();
        handler2 = new Handler(handlerThread.getLooper()){
            @Override
            public void handleMessage(Message msg) {//子线程收到消息后执行
                switch (msg.what){
                    case CODE_TEST_FOUR:
                        Log.e(TAG,"收到主线程发送的消息");
                        break;
                }
            }
        };
        handler2.sendEmptyMessage(CODE_TEST_FOUR);//在主线程中发送消息
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        handlerThread.quit();
    }
}

有关HandlerThread更详细的资料大家可以看这篇博客

Android 进阶15：HandlerThread 使用场景及源码解析

子线程向子线程发送消息

子线程向子线程发送消息的过程和之前讲的差不多，就不赘述了

protected void onCreate(Bundle savedInstanceState) {
	//省略部分代码...
	handlerThread = new HandlerThread("MyHandlerThread");
	handlerThread.start();
	handler2 = new Handler(handlerThread.getLooper()){
		@Override
		public void handleMessage(Message msg) {//子线程收到消息后执行
			switch (msg.what){
				case CODE_TEST_FOUR:
					Log.e(TAG,"收到另一个子线程发送的消息");
					break;
			}
		}
	};

	Thread testThread = new Thread(new Runnable() {
		@Override
		public void run() {
			handler2.sendEmptyMessage(CODE_TEST_FOUR);//在另一个子线程中发送消息
		}
	});
	testThread.start();
}

附录一：Handler发送消息

Handler发送消息多种方法，但无论我们使用哪种方法，其最终都是利用MessageQueue.enqueueMessage方法将消息插入到消息队列中。各种方法内部的执行顺序如下图所示，我们可以从红框内任意一步出发，只需注意该方法的作用及传入参数的区别即可