【Android】系统中几种消息机制的一些开发总结

关于Android系统的消息机制，肯定是在开发中经常会遇见和使用到的，最经常使用到的类莫过于是Handler了，例如：系统允许在非UI线程中去更新UI，这时候就需要handler出现来解决这个问题，最经常使用到的AsyncTask内部其实也是使用了Handler了来进行UI的更新。接下来简单的总结一下在开发过程中使用到几种方式。

一、Thread+Handler

为了避免产生ANR问题，做耗时操作都不会放在UI线程中，会考虑另起一个线程执行，在完成耗时操作后再通知更新UI来提醒用户

[java]  view plain copy print ?

1. new Thread(){  
2.                    @Override  
3.                    public void run() {  
4.                        //执行耗时加载操作......  
5.                        Message msgAsync = workHandler.obtainMessage(HANDLER_SENDMESSAGE_ASYNC , "handler sendMessage Async");  
6.                        workHandler.sendMessage(msgAsync);  
7.                    }  
8.                }.start();  

二、Looper+Handler+MessageQueue+Thread

系统为每一个应用分配一个MessageQueue消息队列，Looper则是负责维护这个消息队列，当处理MessageQueue中的某个消息时候，Looper会将对应的Message交给某个Handler进行处理，最终是调用Handler.CallBack接口中的回调方法来处理这个消息，系统默认的创建的MessageQueue是给app维护UI线程用的，如果我们想要在其他线程里面也也创建一个MessageQueue则可以使用系统提供的Looper类来实现这样操作，具体的代码大概实现如下：

[java]  view plain copy print ?

1. private class LooperThread extends Thread{  
2.   
3.         public final static int SEND_LOOPER_MESSAGE = 1;  
4.         public final static int QUIT_LOOPER = 2;  
5.   
6.         private Handler myHandler;  
7.   
8.         @Override  
9.         public void run() {  
10.             super.run();  
11.             Looper.prepare();  
12.             myHandler = new Handler(){  
13.                 @Override  
14.                 public void handleMessage(Message msg) {  
15.                     super.handleMessage(msg);  
16.                     if (msg.what == SEND_LOOPER_MESSAGE){  
17.                         Log.v(TAG, "handle a message.........");  
18.                         Toast.makeText(MainActivity.this , "other thread..." , Toast.LENGTH_SHORT).show();//显示Toast，不管是否是ui线程都可以做到  
19.                     } else if (msg.what == QUIT_LOOPER){  
20.                         Log.v(TAG, "quit looper .........");  
21.                         Looper.myLooper().quit();  
22.                     }  
23.                 }  
24.             };  
25.             Looper.loop();  
26.         }  
27.   
28.         public Handler getMyHandler(){  
29.             return myHandler;  
30.         }  
31.     }  

大概的思路是新建一个继承重写Thread类，然后在run方法中调用Looper.prepare方法让系统为线程创建一个消息队列，并最终调用Looper.loop来进行消息处理，使用这种方式需要注意一下两点：

1.在自定义线程的MessageQueue不可以做更新UI的操作（原因不用多说）；

2.调用loop之后会进行如一个循环不断的轮询消息，所以loop之后的代码将不会被执行；

三、HandlerThread+Handler

上面总结的第二种方式系统其实为我们提供了一种方式就是使用已经封装好的HandlerThread（是Thread的子类），其原理本质上是一样的，都是在run方法中同样调用了Looper.prepare和Looper.loop来创建一个消息队列，使用方式上有稍微的区别而已。

首先创建并start一个HandlerThread，并获取HandlerThread中的Looper来初始化一个Handler，通过使用Handler来进行消息队列的处理

[java]  view plain copy print ?

1. HandlerThread handlerThread = new HandlerThread("handler_thread");  
2. handlerThread.start();  
3. Handler threadHandler = new Handler(handlerThread.getLooper()){  
4.             @Override  
5.             public void handleMessage(Message msg) {  
6.                 super.handleMessage(msg);  
7.                 Log.e(TAG , "used thread handler");  
8.             }  
9.         };  

以上是我开发过程中的一些小小的总结，第一次在CSDN动手写博客，请阅读的读者多多包涵，如果有什么意见或建议欢迎留下评论，我会继续努力的

转自http://blog.csdn.net/d_clock/article/details/42193879