一. 图解与概述html
首先Android中 的每个线程都会对应一个MessageQueue和Looper。见名知意,MessageQueue即线程用来维护线程产生的消息的消息队列,而这个 队列的调度则是由Looper来完成的。Looper负责将产生的消息放入队列,并及时的将合适的消息从队列中取出并交由合适的接受者处理。处理消息的便 是每一个线程内部的Handler对象,特别是在UI线程中,因为Handler与UI处于同一个线程,因此咱们就能够经过Handler处理接收到的消息 并及时更新UI中的组件。java
上述描述便可以实如今其它线程中完成耗时操做并在UI线程中经过Handler更新组件以反映耗时操做的处理效果。android
如下是它们之 间关系的图示:程序员
理解概念:设计模式
Message:消息,其中包含了消息ID,消息处理对象以及处理的数据等,由MessageQueue统一列队,终由Handler处理。
Handler:处理者,负责Message的发送及处理。使用Handler时,须要实现handleMessage(Message msg)方法来对特定的Message进行处理,例如更新UI等。
MessageQueue:消息队列,用来存放Handler发送过来的消息,并按照FIFO规则执行。固然,存放Message并不是实际意义的保存,而是将Message以链表的方式串联起来的,等待Looper的抽取。
Looper:消息泵,不断地从MessageQueue中抽取Message执行。所以,一个MessageQueue须要一个Looper。
Thread:线程,负责调度整个消息循环,即消息循环的执行场所。
安全
简单关系:多线程
Handler,Looper和MessageQueue就是简单的三角关系。框架
Looper和MessageQueue一一对应,线程和looper也是一一对应,建立一个Looper的 同时,会建立一个MessageQueue。异步
而Handler与它们的关系,只是简单的汇集关系,即Handler里会引用当前线程里的特定Looper 和MessageQueue。
这样说来,多个Handler均可以共享同一Looper和MessageQueue了。ide
固然,这些Handler也就运行在同一个线程里。
消息循环过程:
生成消息
1 Message message = handler.obtainMessage(); 2 message.arg1 = id; 3 message.obj = drawable; 4 handler.sendMessage(message);
发送消息
1 /** 2 * <b>The time-base is {@link android.os.SystemClock#uptimeMillis}.</b> 3 * to this handler. 4 * @param uptimeMillis The absolute time at which the message should be 5 * {@link android.os.SystemClock#uptimeMillis} time-base. 6 * @return Returns true if the message was successfully placed in to the 7 * looper processing the message queue is exiting. Note that a 8 * the looper is quit before the delivery time of the message 9 */
public boolean sendMessageAtTime(Message msg, uptimeMillis) 10 { 11 sent = ; 12 MessageQueue queue = mQueue; 13 (queue != ) { 14 msg.target = ; 15 sent = queue.enqueueMessage(msg, uptimeMillis); 16 } 17 { 18 RuntimeException e = RuntimeException( 19 + , e.getMessage(), e); 20 } 21 sent; 22 }
在 Handler.java的sendMessageAtTime(Message msg, long uptimeMillis)方法中,咱们看到,它找到它所引用的MessageQueue,而后将Message的target设定成本身(目的是为了在 处理消息环节,Message能找到正确的Handler),再将这个Message归入到消息队列中。
Looper从消息队列中抽取消息
1 public static final void loop() { 2 Looper me = myLooper(); 3 MessageQueue queue = me.mQueue; 4 () { 5 Message msg = queue.next(); 6
7
8
9 (msg != ) { 10 (msg.target == ) { 11
12 ; 13 } 14 (me.mLogging!= ) me.mLogging.println( 15 ); 16 msg.target.dispatchMessage(msg); 17 (me.mLogging!= ) me.mLogging.println( 18 + msg.callback); 19 msg.recycle(); 20 } 21 } 22 }
在Looper.Java的loop()函数里,咱们看到,这里有一个死循环,不断地从MessageQueue中获取下一个(next方法)Message,而后经过Message中携带的target信息,交由正确的Handler处理(dispatchMessage方法)。
处理
1 /**
2 * Handle system messages here. 3 */
4 public void dispatchMessage(Message msg) { 5 if (msg.callback != null) { 6 handleCallback(msg); 7 } else { 8 if (mCallback != null) { 9 if (mCallback.handleMessage(msg)) { 10 return; 11 } 12 } 13 handleMessage(msg); 14 } 15 }
在 Handler.java的dispatchMessage(Message msg)方法里,其中的一个分支就是调用handleMessage方法来处理这条Message,而这也正是咱们在职责处描述使用Handler时须要 实现handleMessage(Message msg)的缘由。
至于dispatchMessage方法中的另一个分支,我将会在后面的内容中说明.
至此,咱们看到,一个Message经由Handler的发送,MessageQueue的入队,Looper的抽取,又再一次地回到Handler的怀抱。而绕的这一圈,也正好帮助咱们将同步操做变成了异步操做。
Handler所处的线程及更新UI的方式
在 主线程(UI线程)里,若是建立Handler时不传入Looper对象,那么将直接使用主线程(UI线程)的Looper对象(系统已经帮咱们建立 了);在其它线程里,若是建立Handler时不传入Looper对象,那么,这个Handler将不能接收处理消息。在这种状况下,通用的做法是:
1 class LooperThread extends Thread { 2 public Handler mHandler; 3 public void run() { 4 Looper.prepare(); 5 mHandler = new Handler() { 6 public void handleMessage(Message msg) { 7 // process incoming messages here
8 } 9 }; 10 Looper.loop(); 11 } 12 }
在建立Handler以前,为该线程准备好一个Looper(Looper.prepare),而后让这个Looper跑起来(Looper.loop),抽取Message,这样,Handler才能正常工做。
所以,Handler处理消息老是在建立Handler的线程里运行。而咱们的消息处理中,不乏更新UI的操做,不正确的线程直接更新UI将引起异常。所以,须要时刻关心Handler在哪一个线程里建立的。
Message中文是消息,及线程处理的最小单元,里面带有处理的数据集,或还带有操做,及告诉目的地要作什么事情, 每一个MessageQueue里包含有Message。每一个Message不是直接插入到MessageQueue里的,而是经过MessageQueue.IdleHandler 与looper一块儿工做,把Message放到MessageQueue里,及addIdleHandler(MessageQueue.IdleHandler handler) 和removeIdleHandler(MessageQueue.IdleHandler handler) 方法,把MessageQueue.IdleHandler压入到MessageQueu里。
2,Thread和HandlerThread的关系
HandlerThread就是带有Looper循环的Thread.
3,Looper介绍
Looper即一个循环,必须绑定到一个固定的线程里,经过getThread()方法能够得到该looper绑定的Thread对象,经过 getMainLooper()得到主线程里的looper对象,myLooper()能够得到当前线程里的looper对象,经过myQueue()方 法能够得到当前线程里的messageQueue对象。
4,Thread、HandlerThread、和Looper的关系的关系
通常声明一个thread是没有带looper循环的,可是能够经过Looper.prepare()方法给一个线程加上 looper;Looper.loop()执行该looper绑定的线程里的messageQueue,直到该loopger结 束;Loop.quit()结束该循环,实例代码以下:
1 class LooperThread extends Thread { 2 public Handler mHandler; 3
4 public void run() { 5 Looper.prepare(); 6
7 mHandler = new Handler() { 8 public void handleMessage(Message msg) { 9 // process incoming messages here
10 } 11 }; 12
13 Looper.loop(); 14 } 15 }
5,Handler和Thread HandlerThread Looper Message MessageQueue的关系
它把消息发送到该生成它的线程里的MessageQueue里,而后当Message出队列的时候,就执行该消息。
post(Runnable), , ,是用来处理runnable对象的;postAtTime(Runnable, long)postDelayed(Runnable, long)
sendEmptyMessage(int), , , and sendMessage(Message)sendMessageAtTime(Message, long)sendMessageDelayed(Message, long)方法是
能够经过handleMessage (Message msg) 方法来接收消息。
实例化:Handler(Looper looper)

二. 多线程与异步
当程序启动的时候android会自动建立一个进程和一个线程,这个线程负责界面更新,收集系统事件和用户的操做事件等并分配给对应的组件,因此这个线程很是重要 被称为主线程,由于所的和UI有关的操做都是在这个线程当中进行的因此也被称做UI线程。因此说默认状况下主线程和UI线程指的是同一个线程。
Android的UI系统参考了不少SWT的设计模式。好比,UI线程机制,底层JNI实现 etc.
Android 的UI系统是非线程安全的,意思是说只有建立UI的线程(也就是主线程)才能够对UI进程操做。若是咱们在其它线程中执行了一些操做,而这些操做的结果又须要经过UI展示给用户,必需把这更新UI的操做转移到到UI线程中执行。
不少Java起步的程序员对UI线程中的"消息循环"会感受陌生。其实就是在线程内部有一个死循环一直监听系统事件(用户的操做等)并把任务分发给对应的 组件(有兴趣的能够看看NDK附带的native-activity的一个sample,在c中的实现方式就是一个while(1)的死循环)。主线程通 过Looper实现了消息的循环处理。
若是一个线程里边有一个死循环,那么这个循环就会一直在死循环里边循环,而且这个线程不会过多的cpu资源,那么这个线程确定的阻塞的。若是线程只是一直 循环没有什么意义,实际状况一般须要线程根据不一样的条件运行不一样的方法。咱们一般的做法可能会加一个switch开关,根据条件的不一样去调用不一样的方法。
线程间通讯(最多见的就是,worker线程须要更新UI),这个时候实际是包含两个内容:一,数据的传递;二,方法的传递; Android中的Message用于数据传递,而Handler就是方法传递(实际上是方法的执行者,Handler会把这个方法放到Handler所在 的线程当中去执行);MessageQueue是Message的容器和Java中的Queue同样都是容器,只不过Message Queue是专门用于装载Message的容器。Looper则是一个线程中的死循环用于管理MessageQueue,它负责阻塞读取 MessageQueue中的信息(若是MessageQueue中没有信息会一直在那里),挨个读取并把这个Message分发给对应的Handler 去执行。
首先看一下mHandler.obtainMessage(SHOW_ALERT, Greetings).sendToTarget();会执行什么。
经过查看Handler的源码发现执行了下边的代码。
1 public final Message obtainMessage(int what, Object obj){ 2 return Message.obtain(this, what, obj); 3 }
1 public static Message obtain(Handler h, int what, Object obj) { 2 Message m = obtain(); 3 m.target = h; 4 m.what = what; 5 m.obj = obj; 6 return m; 7 } 8 /**
9 * Return a new Message instance from the global pool. Allows us to 10 * avoid allocating new objects in many cases. 11 */
12 public static Message obtain() { 13 synchronized (mPoolSync) { 14 if (mPool != null) { 15 Message m = mPool; 16 mPool = m.next; 17 m.next = null; 18 return m; 19 } 20 } 21 return new Message(); 22 }
看到这里咱们应该明白为何Google建议咱们使用obtainMessage而不是new一个Message.这也是符合了Android中的对象回收机制。
1 public void sendToTarget() { 2
3 target.sendMessage(this);//targe就是一个Handler
4
5 } 6 sendMessage()会调用下面的sendMessageAtTime()把Message加入MessagQueue; 7
8 public boolean sendMessageAtTime(Message msg, long uptimeMillis){ 9 boolean sent = false; 10 MessageQueue queue = mQueue; 11 if (queue != null) { 12 msg.target = this; 13 sent = queue.enqueueMessage(msg, uptimeMillis); 14 }else { 15 RuntimeException e = new RuntimeException( 16 this + " sendMessageAtTime() called with no mQueue"); 17 Log.w("Looper", e.getMessage(), e); 18 } 19 return sent; 20 }
到此咱们的Message对象被加入到了Handler所在线程(也就是主线程)中的MessageQueue这个存储和管理Message的容器当中。下一步就该由Looper接手一个一个的取出Message对象处理了。Looper最主要的方法就是loop()方法
1 public static final void loop() { 2 Looper me = myLooper(); 3 MessageQueue queue = me.mQueue; 4 while (true) {//死循环
5 Message msg = queue.next(); // might block
6 if (msg != null) { 7 if (msg.target == null) {//退出死循环的机制 8 // No target is a magic identifier for the quit message.
9 return; 10 } 11 if (me.mLogging!= null) me.mLogging.println( 12 ">>>>> Dispatching to " + msg.target + " "
13 + msg.callback + ": " + msg.what 14 ); 15 msg.target.dispatchMessage(msg);//target of a msg is a Handler
16 if (me.mLogging!= null) me.mLogging.println( 17 " Finished to " + msg.target + " "
18 + msg.callback);//msg.callback is a Runnable
19 msg.recycle(); 20 } 21 } 22 }
Looper会一直阻塞读取MessagQueue中的Message对象(Message msg = queue.next()),当读取到一个Message时就会调用msg.target.dispatchMessage(msg)把这个 Message分发给对应的Handler去处理,等Handler把任务处理完了再接着读取下一个Message对象并处理。
1 /**
2 * Handle system messages here. 3 */
4 public void dispatchMessage(Message msg) { 5 if (msg.callback != null) { 6 handleCallback(msg);// call the run method of the runnable object I guess
7 } else { 8 if (mCallback != null) { 9 if (mCallback.handleMessage(msg)) { 10 return; 11 } 12 } 13 handleMessage(msg); 14 } 15 }
最后回来了咱们的handlerMessage(msg);这个方法中。若是是用的不是sendMessage是是Hadler.post(Runnable)会调用
1 private final void handleCallback(Message message) { 2 message.callback.run(); 3 }
这就是为何在Handler中post的Runnable不会开启一个新的线程的缘由。通过上面的追踪咱们应该能明白不是全部 的线程均可以有Handler去执行handlerMessage或者处理Runnalbe的。其必要条件就是这个线程要有一个一直循环的 Looper.Looper一直循环确定要有一个方法能够退出循环。
当咱们调用msg.sendToTarget()的时候,咱们的msg对象应付被压入MessageQueue的尾部。Looper在 MessageQueue的另外一端一个一个的读取信息并处理。根据msg的target属性把cpu分配给对应的Handler去执行任务,这时 Handler会根据msg中的属性调用msg.handleMsg()或者msg.callback.run();当一个msg中的消息处理完返回以后 Looper会把这个msg放入msgPool当中方便下次再重复利用。从而减小对象的建立。Looper再从MessageQueue中读取下一个信 息,如此反复。。
理解了这些其实就不难想象ANR是如何实现的了。当用户执行操做(好比点击了一个按钮)系统会生成一个Message对象,把用户操做的信息写入 Message对象,并把这个Message对象压入MessageQueue队列的尾部。系统过一段时间(通常是五秒)后会再来检查,刚刚放入的信息是 不是已经被处理了,若是信息还在队列中就代表。处理前面信息的过程中发生的阻塞,用户的操做没有及时获得响应。系统弹出ANR对话框。
做个总结:
由于UI线程须要保持一直运行的状态,因此要有一个循环保持这个线程不会死掉,但这个线程又必需阻塞,以减小cpu的消耗。android中的这个循 环就是经过Looper实现的。有了这个 Looper,Looper就占据了整个线程,致使全部的方法想在些线程中运行就必需经过这个Looper,因此要有个方法能够进入这个Looper的内 部。MessageQueue就担当了这个通道 的角色。Message担当了集合的角色。全部在UI线程中运行的方法都必需经过MessageQueue进入Looper内部,无论 是用户定义的方法仍是系统事件包括onCreate(),onStop(),用户点击事件etc..
消息系统的基本原理和构成
从通常的消息系统模型的创建大体构成如下几个部分:
l 消息原型
l 消息队列
l 发送消息
l 消息循环
l 消息获取
l 消息派发
l 消息处理
大体模型图以下:
消息系统模型通常会包括以上七个部分(消息原型,消息队列,消息发送,消息循环,消息获取,消息派发,消息处理)。实际上的核心是消息队列和消息循环,其他部分都是围绕这两部分进行的。
从前面文档的分析中咱们知道Handler就是用来创建消息处理的系统模型,那么和这里基本消息系统模型相比,那么Handler又是如何囊括这七个部分的呢?
在Android中对这六个部分进行了抽象成四个独立的部分:
Handler,Message,MessageQueue,Looper;
Handler可以实现消息系统模型,那么具体是如何进行工做的呢,下面探究一下这其中工做的方法和原理。

四. Handler工做原理分析
要了解Handler工做原理,先看一下这个系统模型具体组成的层次结构框架是个什么样的。
实现Thread的消息循环和消息派发,缺省状况下Thread是没有这个消息循环的既没有Looper;须要主动去建立,而后启动Looper的消息循环loop;与外部的交互经过Handler进行;消息队列,由Looper所持有,可是消息的添加是经过Handler进行;
消息循环和消息队列都是属于Thread,而Handler自己并不具备Looper和MessageQueue;可是消息系统的创建和交互,是Thread将Looper和MessageQueue交给某个Handler维护创建消息系统模型。因此消息系统模型的核心就是Looper。消息循环和消息队列都是由Looper创建的,
而创建Handler的关键就是这个Looper。
一个Thread同时能够对应多个Handler,一个Handler同时只能属于一个Thread。Handler属于哪一个Thread取决于Handler在那个Thread中创建。
在一个Thread中Looper也是惟一的,一个Thread对应一个Looper,创建Handler的Looper来自哪一个Thread,Handler属于哪一个Thread。
故创建Thread消息系统,就是将Thread的Looper交给Handler去打理,实现消息系统模型,完成消息的异步处理。
Handler与Thread及Looper的关系能够用下面图来表示:
Handler并不等于Thread,必须经过Thread的Looper及其MessageQueue,用来实现Thread消息系统模型,依附于Thread上。
在线程创建Handler时:
使Handler知足消息系统须要的条件,将Thread中的Looper和MessageQueue交给Handler来负责维护。
在线程中创建Handler,须要作如下工做:
l 获取Thread中的Looper交给Handler的成员变量引用维护;
l 经过Looper获取MessageQueue交给Handler的成员变量引用维护。
那么消息系统模型创建完成以后,按照消息系统运行,从Handler来看就是发送消息派发消息,与此线程消息系统的交互都由Handler完成。
消息发送和派发接口:
l post(runnable)消息,Runnable是消息回调,通过消息循环引起消息回调函数执行;
l sendMessage(Message)消息,通过消息循环派发消息处理函数中处理消息;
l dispatchMessage 派发消息,如果post或带有回调函数则执行回调函数,不然执行
消息处理函数Handler的handleMessage(一般派生类重写)。
以上就是Handler如何实现Thread消息系统模型的大体介绍, 下面将具体分析是如何实现消息系统模型运行的。

五. Handler实现流程分析
咱们知道Handler就是一个消息系统的外壳,属于某个Thread并包装了Thread的Looper及其MessageQueue;与外部进行交互(同一个线程内或者线程之间),接收派发和处理消息,消息系统模型的核心是Looper。下面看看Handler是如何创建跑起来的,以msg消息为例,runnable实质是同样。
Handler惟一属于某个Thread,在某个Thread中创建Handler时,须要获取Thread的Looper及其MessageQueue,创建Handler关键是Looper的来源。
Handler提供了好几个构造函数但其本质一致:
由外部传入Looper:当前线程或其余线程
public Handler(Looper looper) { //初始化构建消息系统参数 mLooper = looper; mQueue = looper.mQueue; mCallback = null; }
从当前线程获取:由建立Handler的Thread决定
public Handler() { //初始化构建消息系统参数 mLooper = Looper.myLooper(); mQueue = mLooper.mQueue; mCallback = null; } public static Looper myLooper() { return sThreadLocal.get(); }
无论哪一种方式,咱们知道Thread在默认状况下是没有创建消息循环Looper实例的。
要实现消息循环必须确保Thread的Looper创建。如何确保呢?
Looper提供了静态函数:
public static void prepare() { if (sThreadLocal.get() != null) { throw new RuntimeException("Only one Looper may be created per thread"); } sThreadLocal.set(new Looper()); } //存储线程的局部变量 static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
每个线程调用Looper.prepare时,都会建立为其惟一的Looper。
要创建Handler,须要先建立线程的Looper,才能创建消息系统模型。经过Looper咱们创建了
Thread上的消息系统模型Handler,能够来进行消息系统的一系列流程了。
消息发送两种方式:post和sendMessage;
post:针对runnable对象;Runnable是一个接口,就是一个回调函数(提供了run方法)
sendMessage:针对Message对象;
下面经过代码具体看一下这个过程:
public final boolean post(Runnable r){ return sendMessageDelayed(getPostMessage(r), 0); } public final boolean sendMessage(Message msg){ return sendMessageDelayed(msg, 0); }
看到post和sendMessage发送消息时,仅仅是对象不一样而已,Runnable和Message;
但实际上都是Message的形式来描述。
这跟我一般理解的消息机制不一样:
一般post消息是将消息加入到消息队列中并不当即执行就返回,send消息是当即执行等待消息执行完才返回。
而这里post或者send都是将消息放入到消息队列中,而后当即返回,等待消息循环时获取消息被执行。
这里提供了众多的消息发送方法来指定消息的执行时间和顺序,具体能够查看源代码。
消息执行顺序是根据消息队列中消息的排列顺序而定。
下面看一下发送消息后将消息加入到消息队列中的代码:
由Handler调用MessageQueue的enqueueMessage方法:
1 final boolean enqueueMessage(Message msg, long when) { 2
3 Message p = mMessages; 4
5 if (p == null || when == 0 || when < p.when) { 6 msg.next = p; 7 mMessages = msg; 8 } 9 else { 10
11 Message prev = null; 12 while (p != null && p.when <= when) { 13 prev = p; 14 p = p.next; 15 } 16
17 msg.next = prev.next; 18 prev.next = msg; 19 } 20 …… 21 }
能够看到是按照时间顺序将消息加入到MessageQueue中;
如今将消息加入到消息队列中存储起来,消息并未获得处理,下一步必然是如何派发消息和处理消息。
创建Thread消息循环由Looper完成,存在一个消息调度死循环:
public static void loop() { MessageQueue queue = me.mQueue; while (true) { Message msg = queue.next(); // might block if (msg != null) { if (msg.target == null) { // No target is a magic identifier for the quit message. return; } //派发消息 到target(Handler) msg.target.dispatchMessage(msg); //回收Msg到msgPool msg.recycle(); } } }
这里看到消息派发是由Message的target完成,这个target是什么呢?是一个Handler。
消息系统是经过Handler用来与外部交互,把消息派发出去。能够看到没有这个Handler,消息循环将结束。
消息派发由Looper经过Handler完成:
public void dispatchMessage(Message msg) { //首先判断runnable对象 if (msg.callback != null) { handleCallback(msg); } else { //整个消息系统的回调函数 能够不用实现本身Handler if (mCallback != null) { if (mCallback.handleMessage(msg)) { return; } } //消息处理 一般交给Handler派生类 handleMessage(msg); } }
经过消息派发,这样就实现消息的异步处理。
前面看到消息发送有两种方式:
post(Runnable对象),sendMessage(Message对象),而中间都是经过Message对象保存在MessageQueue中。而后消息派发时处理方式不一样。若是在sendMessage时将将消息对象附上Runnable对象,则post和sendMessage没有区别了。因此这两种方式很好理解基本一致,处理的方式不一样罢了。
消息系统模型中,咱们的真正的消息原型是什么,都具备那些功能,下面看一下Message中到底包含了那些东西,能有效帮助咱们合理的运用消息系统来完成一些任务和处理。
Message消息原型:
public final class Message implements Parcelable { //标识消息 public int what; int flags; long when; //传递简单数据 public int arg1; public int arg2; //传递较复杂数据 对象 public Object obj; Bundle data; //处理消息的目标Handler Handler target; //消息派发时 执行的Runnable对象 Runnable callback; //使消息造成链表 Message next; //创建一个消息pool,回收msg,以免重复建立节约开销 private static Message sPool; private static int sPoolSize = 0; private static final int MAX_POOL_SIZE = 10; }
看到提供了很丰富的属性来描述消息,针对具体问题选择使用那些属性去怎么样描述消息了。
获取新的Message对象时,Message提供了obtain方法:避免咱们本身去分配Message新的对象,经过obtain获取,可能从MessagePool中获取,节约开销。
下面看一下这个MessagePool是如何创建的:
一般消息处理完毕的时候,消息也基本上处于无用状态能够释放回收了。对于须要频繁的建立释放的对象来讲,建立和释放类实例都是要开销的,太频繁的使开销增大很差,像Message这种颇有可能会频繁的建立。
因而咱们能够将建立的对象用完以后保存在一个Pool里面,以便再重复利用节约频繁建立释放开销。是如何创建的呢?必然是在消息处理完毕以后才能进行。
MessagePool创建:
public static void loop() { while (true) { //派发消息 msg.target.dispatchMessage(msg); //消息处理完毕 回收 msg.recycle(); } } public void recycle() { //回收Message 创建全局的MessagePool if (sPoolSize < MAX_POOL_SIZE) { next = sPool; sPool = this; sPoolSize++; } }

以上这就是整个Handler做用及消息系统模型的创建。
使用也很是简单,虽然有不少方式,但只要理解Handler是创建在Looper上,实现Thread的
消息系统处理模型,实现消息异步处理,我想对与Handler基本应用上没有什么不能理解的了。
其余方面能够去看源码了。
Handler使用起来是很是简单的,关键就是如何利用消息的异步处理,来合理的完成咱们
须要功能和任务。对于一个Thread,咱们使用好几个Handler来进行异步处理,也能够建立新的Thread,
经过Handler来实现消息异步处理等等,应用场景不少如何用的好用的合理,这就没什么经验了。
至于如何使用,源码中不少例子能够看一下AsyncQueryHandler这个类,其中两个线程,
完成查询工做,经过Handler进行线程之间有消息传递。感受这个利用的很好很巧妙。