Handler: 主线程如何通知子线程

在 android 中，不可以在子线程中更新 UI 的操作，否则会报错或者异常信息。

在这种情况下，我们会使用 Handler（在 UI 线程创建该对象） 接收子线程的消息更新 UI.

可以看出，这是子线程通知主线程，而主线程没有直接通知子线程，那麽我们如何做到这一点？这样有什么好处？

好处，很明显。主线程中如果有些耗时的操作，我们可以让子线程去做，这时，主线程就可以通知子线程了！

实现这种操作的方式有很多，今天主要想说说 HandlerThread 与 Handler 的配合使用方法。

在主线程中，可以创建 HandlerThread 对象：

view plain print ?

1. HandlerThreadmHandlerThread=newHandlerThread("sub_thread");
2. mHandlerThread.start();

这样，就开启了一个子线程，该线程的名字就是 sub_thread.

然后，我们实现一个继承自 Handler 的 MyHandler 类：

view plain print ?

1. classMyHandlerextendsHandler{
3. publicMyHandler(){
4. super();
5. }
7. publicMyHandler(Looperlooper){
8. super(looper);
9. }
11. @Override
12. publicvoidhandleMessage(Messagemsg){
13. //super.handleMessage(msg);
14. if(msg.what==MSG_WHAT){
15. Bundlebundle=msg.getData();
16. Stringinfo=bundle.getString("main");
17. Log.d("mark","我接受任务："+info);
18. }
19. }
20. }

最后，使用 Message 来传递消息，MyHandler 会根据情况处理 Message.

完整代码：

view plain print ?

1. packagemark.zhang;
3. importandroid.app.Activity;
4. importandroid.os.Bundle;
5. importandroid.os.Handler;
6. importandroid.os.HandlerThread;
7. importandroid.os.Looper;
8. importandroid.os.Message;
9. importandroid.util.Log;
11. publicclassHandlerThreadActivityextendsActivity{
13. privatestaticfinalintMSG_WHAT=1;
15. @Override
16. publicvoidonCreate(BundlesavedInstanceState){
17. super.onCreate(savedInstanceState);
18. setContentView(R.layout.main);
20. //创建对象，并启动该线程
21. HandlerThreadmHandlerThread=newHandlerThread("sub_thread");
22. mHandlerThread.start();
23. //获取Looper对象
24. MyHandlermHandler=newMyHandler(mHandlerThread.getLooper());
25. //创建Bundle对象，传递数据
26. Bundlebundle=newBundle();
27. bundle.putString("main","我这边事情太多，麻烦你帮忙处理一下！");
28. //发送消息
29. Messagemsg=newMessage();
30. msg.what=MSG_WHAT;
31. msg.setData(bundle);
32. msg.setTarget(mHandler);
33. msg.sendToTarget();
35. Log.d("mark","UI----"+"threadName:"+Thread.currentThread().getName()+"，threadId:"+Thread.currentThread().getId());
36. }
38. /**
39. *该Handler调用handleMessage方法运行在子线程
40. *
41. *@authormark
42. */
43. classMyHandlerextendsHandler{
45. publicMyHandler(){
46. super();
47. }
49. /*这个构造方法必须有*/
50. publicMyHandler(Looperlooper){
51. super(looper);
52. }
54. @Override
55. publicvoidhandleMessage(Messagemsg){
56. if(msg.what==MSG_WHAT){
57. Bundlebundle=msg.getData();
58. //接收消息
59. Stringinfo=bundle.getString("main");
60. Log.d("mark","handleMessage---"+"threadName:"+Thread.currentThread().getName()+"，threadId:"+Thread.currentThread().getId());
61. Log.d("mark","我接受任务："+info);
62. }
63. }
64. }
65. }

这里，我们思考一个问题，代码：

view plain print ?

1. //获取Looper对象
2. MyHandlermHandler=newMyHandler(mHandlerThread.getLooper());

获取 Looper 对象，使用的是 HandlerThread 对象的 getLooper 对象。为什么不直接这样：

view plain print ?

1. //获取Looper对象
2. MyHandlermHandler=newMyHandler(getMainLooper());

如果这样做的话，打印信息如下：

view plain print ?

1. D/mark(21852):UI----threadName:main，threadId:1
2. D/mark(21852):handleMessage---threadName:main，threadId:1
3. D/mark(21852):我接受任务：我这边事情太多，麻烦你帮忙处理一下！

可见，此时的 handleMessage 是在主线程中运行的。每个主线程默认有一个 Looper，也就是说在主线程中，下面代码是等效的：

view plain print ?

1. MyHandlermHandler=newMyHandler(getMainLooper());
3. MyHandlermHandler=newMyHandler();

但是子线程需要手动获取如：

view plain print ?

1. MyHandlermHandler=newMyHandler(mHandlerThread.getLooper());

实现主线程、子线程双向通信可以在各自的线程中分别是用 Handler 来传递信息和处理消息。