关于android消息处理的个人理解

1、thread线程，主要负责调度整个消息循环，即消息循环的场所。

分为普通线程，消息线程（Looperthread）。

普通线程就是从Thread派生的线程。

消息线程（Looperthread）：首先从Thread派生，然后在run方法中调用Looper.preapare()和Looper.loop方法；一个消息线程大概如下所示：

classLooperThreadextendsThread{

publicHandlermHandler;

publicvoidrun(){

Looper.prepare();

mHandler=newHandler(){

publicvoidhandleMessage(Messagemsg){

//processincomingmessageshere

}

};

Looper.loop();

}

}

在run()方法中的Handler变量负责消息的处理。当然此变量的初始化，可以放在其他地方，比如，直接在声明的时候使用匿名类来初始化。采用如下所示的方式：

publicHandlermHandler=newHandler(){

publicvoidhandleMessage(Messagemsg){

//yourprocessmethod

}

}

2、looper，消息泵，不间断的从messageQueue中抽取Message，并进行message的分发。

一个looper中包含了一个MessageQueue，其所处理的Message都是从这个消息队列中取出的。

另外还包含了一个ThreadLocal变量，privatestaticfinalThreadLocalsThreadLocal=newThreadLocal();从本质上来说一个Looper就是一个ThreadLocal，

从Looper的myLooper()方法可以知道：

publicstaticfinalLoopermyLooper(){

return(Looper)sThreadLocal.get();

}

从prepare()可以得知，一个线程中只能有一个Looper：

publicstaticfinalvoidprepare(){

//当已经设置过looper则会抛出异常。

if(sThreadLocal.get()!=null){

thrownewRuntimeException("OnlyoneLoopermaybecreatedperthread");

}

sThreadLocal.set(newLooper());

}

构造函数代码如下：

privateLooper(){

mQueue=newMessageQueue();

mRun=true;

mThread=Thread.currentThread();

}

从构造函数可知，在prepare的时候会创建一个新的MessageQueue，并将looper的线程变量设置为当前正在运行的线程，也就是调用Looper.prepare()方法的线程。

Looper的主线程处理，主要有以下两个方法：

publicstaticfinalvoidprepareMainLooper(){

prepare();

setMainLooper(myLooper());

if(Process.supportsProcesses()){

myLooper().mQueue.mQuitAllowed=false;

}

}

privatesynchronizedstaticvoidsetMainLooper(Looperlooper){

mMainLooper=looper;

}

这两个方法都不能被应用程序使用，在ActivityThread的main()方法中调用了prePareMainLooper()方法：

publicstaticfinalvoidmain(String[]args){

SamplingProfilerIntegration.start();

Process.setArgV0("<pre-initialized>");

Looper.prepareMainLooper();

ActivityThreadthread=newActivityThread();

thread.attach(false);

Looper.loop();

if(Process.supportsProcesses()){

thrownewRuntimeException("Mainthreadloopunexpectedlyexited");

}

thread.detach();

Stringname=(thread.mInitialApplication!=null)

?thread.mInitialApplication.getPackageName()

:"<unknown>";

Slog.i(TAG,"Mainthreadof"+name+"isnowexiting");

}

main()方法作为应用程序的入口，在这里设置了主线程的looper。注：在ActivityThread中加载了应用程序的启动activity，因此主线程也可以叫做UI线程。

loope()方法是一个无限循环，下面是其代码：

publicstaticfinalvoidloop(){

//获取当前线程的looper

Looperme=myLooper();

MessageQueuequeue=me.mQueue;

while(true){

//获取下一个消息

Messagemsg=queue.next();//mightblock

//如果消息不是null，并且消息的handler为null，则退出，说明是一个空消息，则退出循环。

if(msg!=null){

if(msg.target==null){

//Notargetisamagicidentifierforthequitmessage.

return;

}

。。。。

//分发消息，使用消息的handler进行消息的分发操作

msg.target.dispatchMessage(msg);

。。。。。

//清空消息

msg.recycle();

}

}

}

3、Message，代表消息包含了消息的类型(what属性确定，在每个线程中唯一），消息的参数（共两个分别为arg1，arg2，int型），以及一个Bundle对象用于传递Object类型数据。

Message定义了需要被处理的时间(when属性,long型，该时间基于手机开机时间，在开机时间多长时间后进行消息处理），处理目标(target，Handler型，target进行消息的分发处理）

回调操作，callback，Runnable类型，如果指定了此属性在target进行消息分发时，会执行该回调的run方法，而不进行Message的what信息判断和消息参数的处理。

Message的获取方法：

1）、构造方法，newMessage();不推荐使用

2）、obtain()系列方法，在该系列的方法中设置了Message的各种参数，具体配置参考代码。该方法推荐使用。

Message仅仅作为需要传递的信息的一个载体，同时指定需要处理该信息的target，target进行消息的分发处理。

4、MessageQueue，消息队列（其实是一个链表结构，使用Message类型的next变量进行连接，在此链表中，每个数据按照要执行的时间从大到小进行排序），负责消息的缓存和消息从消息队列中的取出操作。

每一个消息都按照执行时间大小插入到列表中，这样可以保证需要立即执行的消息得到及时的执行。

从消息队列中取出消息操作，首先会判断是否当前消息需要被执行（通过消息的执行时间和当前时间进行比较）。

消息队列的创建是在构建Looper的时候进行创建的。这样可以保证一个线程中只有一个消息队列，而每个消息可以有不同的handler，也就是一个线程可以有多个Handler。

5、Handler，消息的处理者，负责消息的发送和处理，实现根据消息进行UI更新，文件读取等操作。

1）Handler的构建。a）、继承Handler类，并重写handleMessage方法。b）、实现Handler类中的Callback接口，并实现其handleMessage方法。，其中第一种方法可以通过构建一个新的Handler子类，然后创建新子类的变量，或者通过使用匿名类方法创建变量的方法来创建Handler变量。

第二种方法使用Handler的类先实现Handler的Callback接口，然后在创建Handler变量的时候，使用带参数的Handler构造方法，并将使用Handler类的this变量传递给构造方法。

两种方法的示例分别如下：

//第一种方法

publicclassActivity1extendsActivity{

publicHandlerhandler=newHandler(){

publicvoidhandleMessage(Messagemsg){

//yourprocesscode

}

}

********

}

//第二种方法，实现Callback接口

publicclassActivity2extendsActivityimplementsHandler.Callback{

publicbooleanhandleMessage(Messagemsg){

//yourprocesscode

}

//创建变量时可以使用下面两种方法的任意一种

Handlerhandler=newHanlder(this);

Handlerhandler2=newHandler(Looper.myLooper(),this);

******

}

Handler的dispatchMessage方法，负责消息的分发，调用具体的消息处理函数

publicvoiddispatchMessage(Messagemsg){

//如果message的回调不是null，则执行message的callback

if(msg.callback!=null){

handleCallback(msg);

}else{

//如果避免子类化回调不是null，则执行此回调

if(mCallback!=null){

if(mCallback.handleMessage(msg)){

return;

}

}

//如果子类化回调没有执行成功，则执行子类的handleMessage

handleMessage(msg);

}

}

sendMessage**()方法，用于将消息插入到消息队列中。并设定消息执行的事件，如果传递的是一个没有target的消息则会终止Looper的loop操作，也就是说会终止整个消息循环。

​post*()方法都会创建一个新的message，并在指定的时间执行消息。在这些方法中指定了Message的callback方法，因此需要执行的操作就是callback的中的run方法。

6、activity：UI，所有的UI都在一个线程中，即UI线程。因此在Activity中创建的Handler变量也属于UI线程，因此通常情况下在使用handler进行Ui更新操作可以成功就是因为这个原因。

UI线程是由android在启动应用程序的时候创建的。

7、消息循环的过程：

1、构建消息线程，在调用Looper.prepare()方法时创建了MessageQueue变量。

2、构建Handler变量，并重写handleMessage方法，在构建Handler变量时会将Looper的MessageQueue变量传递给hanler。

3、创建工作者线程，在线程的run方法中创建Message变量，示例代码如下：

Messagemsg=handler.obtain();

//设置msg的参数，一下为参考代码，根据具体情况可以设置不同的值

msg.what=1;

msg.arg1=2;

msg.arg2=3;

Bundledata=newBunlde();

Bundlebundle=newBundle();

//调用bundle的put方法来保存数据

bundle.put**();

msg.setData(data);

//1、此消息的when设置为当前时间(该时间基于开机时间），

//2、设置Message的target为调用sendMessage的handler，

//3、将Message插入到Looper的MessageQueue中

handler.sendMessage(msg);

4、Looper的loop函数进行了从MessageQueue中获取Message，

5、调用Message的target的dispatchMessage()方法分发消息。

6、在dispatch中根据不同条件调用不同的消息处理方法。

7、调用Message的recycle()方法清空消息，到此处消息结束其生命。

获取当前线程的looper：Looper.myLooper();

获取looper的MessageQueue：looper.mQueue;

获取message的target：message.target;

关于Service和线程的关系，service不是一个线程，和activity一样是应用程序的一部分，一般情况下运行在主线程中，如果AndroidMenifest.xml文件中注册sevice时，指定了其android:process属性，则运行在其他进程中。

关于service的参考网址：http://blog.csdn.net/ahcyd008/article/details/7577986