关于这个话题,其实很早之前就想撰写相关来的稳当来加加深映像,或者当做技术笔记,但是一直都不知道从哪里开始比较合适.先看看网上给出的相关的定.
Hanlder作用:
1）执行计划任务，你可以再预定的实现执行某些任务，可以模拟定时器
2）线程间通信。在Android的应用启动时，会创建一个主线程，主线程会创建一个消息队列来处理各种消息。当你创建子线程时，你可以再你的子线程中拿到父线程中创建的Handler对象，就可以通过该对象向父线程的消息队列发送消息了。由于Android要求在UI线程中更新界面，因此，可以通过该方法在其它线程中更新界面。 
一、 角色描述
1．Looper:(相当于隧道) 一个线程可以产生一个Looper 对象，由它来管理此线程里的Message Queue( 车队,消息隧道) 。
2．Handler: 你可以构造Handler 对象来与Looper 沟通，以便push 新消息到Message Queue 里；或者接收Looper( 从Message Queue 取出) 所送来的消息。
3．Message Queue( 消息队列): 用来存放线程放入的消息。
4．线程：UI thread 通常就是main thread ，而Android 启动程序时会替它建立一个Message Queue 。
每一个线程里可含有一个Looper 对象以及一个MessageQueue 数据结构。在你的应用程序里，可以定义Handler 的子类别来接收Looper 所送出的消息。
二、 执行过程
当我们在子线程创建一个Handler的时候,目的就是就可以通过该对象向父线程的
消息队列发送消息了，那么这个handler对象是怎么实现的呢? 其实,当创建好一个Handler的时候,在Handler的构造方法中会获得一个主线程的消息队列监听器 —— Looper.这里简单说一下Looper，,我们可以理解它为一个隧道或者是一直循环的监听器,我们通常说的Looper都是主线程Looper,当主线程启动的时候,它会通过Looper的prepareMainLooper()方法,获得当前线程的Looper实例,然后让Looper调用loop方法不断地循环来处理message方法.看下面
代码
public static final void main(String[] args) {
SamplingProfilerIntegration.start();
Process.setArgV0("<pre-initialized>");
Looper.prepareMainLooper();
if (sMainThreadHandler == null) {
sMainThreadHandler = new Handler();
}
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
Looper.loop();
好吧,可能这里很难理解,所以我们一点儿一点儿地来分析.然后再说handler怎么
发挥作用的.
先看 Looper.prepareMainLooper(),这里发生了什么？
public static final void prepareMainLooper() {
prepare();
setMainLooper(myLooper());
if (Process.supportsProcesses()) {
myLooper().mQueue.mQuitAllowed = false;
}
}
看上面的代码可以知道,首先Looper的prepareMainLooper()方法中调用了 prepare()方法,这个方法作用是赋予当前线程一个新的Looper对象,看代码:
public static final void prepare() {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created
per thread");
}
sThreadLocal.set(new Looper());
}
好了,明白了这个方法,那下一个方法setMainLooper(myLooper())呢? 继续看源代码！我们先来看myLooper()方法.
public static final Looper myLooper() {
return (Looper)sThreadLocal.get();
}
这个方法很简单,它的作用就是获得当前线程的Looper对象,前面我们刚刚赋予了 一个Looper对象给当前线程,这里便获取了它,是不是有种遥相呼应的感觉.. (再次声明,这里的当前线程指的是主线程或是UI线程),我们再来看看 setMainLooper()方法：
private synchronized static void setMainLooper(Looper looper) {
mMainLooper = looper;
}
也很简单,和之前的myLooper()方法就是把从当前线程获得Looper赋给一个mMainLooper的变量.
好了,总结一下,Looper.prepareMainLooper();的作用就是我们之前说的获得当前线程的Looper实例.下面再到 Looper.loop();看看
public static final void loop() {
Looper me = myLooper();
MessageQueue queue = me.mQueue;
// Make sure the identity of this thread is that of the local
process,
// and keep track of what that identity token actually is.
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
while (true) {
Message msg = queue.next(); // might block
//if (!me.mRun) {
// break;
//}
if (msg != null) {
if (msg.target == null) {
// No target is a magic identifier for the quit
message.
return;
}
if (me.mLogging!= null) me.mLogging.println(
">>>>> Dispatching to " + msg.target + " "
+ msg.callback + ": " + msg.what
);
msg.target.dispatchMessage(msg);
if (me.mLogging!= null) me.mLogging.println(
"<<<<< Finished to " + msg.target + " "
+ msg.callback);
// Make sure that during the course of dispatching the
// identity of the thread wasn't corrupted.
final long newIdent = Binder.clearCallingIdentity();
if (ident != newIdent) {
Log.wtf("Looper", "Thread identity changed from
0x"
+ Long.toHexString(ident) + " to 0x"
+ Long.toHexString(newIdent) + " while
dispatching to "
+ msg.target.getClass().getName() + " "
+ msg.callback + " what=" + msg.what);
}
msg.recycle();
}
}
}
这个方法看起来很复杂,其实我们只需要关注里面关键的几个点就行了.
1. Looper me = myLooper();刚才说过,就是获得当前线程(即主线程)的Looper.
2. MessageQueue queue = me.mQueue;这个2.MessageQueue在前面已经做了详细 的介绍,所以就不做解释了,但是突然出现在这里,有点莫名其妙......其实非也, 我们可以看到queue是来至于me.mQueue,就是Looper中的一个成员变量,这个 queue是什么时候产生的呢？ 其实还记得刚才的prepare() 方法么.这个方法中 实例化了一个Looper——new Looper().queue就是来自于Looper的构造方法,请 看代码就会明白了.
private Looper() {
mQueue = new MessageQueue();
mRun = true;
mThread = Thread.currentThread();
}
所以不是莫名其妙,是有根据的.
3. Message msg = queue.next()，在循环体中看到的这段代码当然就是不断地将queue中的message一个一个地取出来啦!
4. msg.target.dispatchMessage(msg);经过之前一系列的判断处理之后,来到了loop()方法中非常核心的地方,这里作用就是把这个从queue中获得的message分发给相应的地方来进行处理.好了。。。说了半天,终于能回到我们开始说的Handler了.
当时Handler怎么做才能和之前的步骤产生联系呢? Handler的使用我们必须先实例化并实现它的handleMessage方法.呵呵,其实这个 只是一个引子......当我们实例化Handler的时候其实就是和之前说过的Looper还有什么queue，产生联系的时候,继续看代码:
public Handler(Callback callback) {
if (FIND_POTENTIAL_LEAKS) {
final Class<? extends Handler> klass = getClass();
if ((klass.isAnonymousClass() || klass.isMemberClass() ||
klass.isLocalClass()) &&
(klass.getModifiers() & Modifier.STATIC) == 0) {
Log.w(TAG, "The following Handler class should be
static or leaks might occur: " +
klass.getCanonicalName());
}
}
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not
called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = callback;
}
这下看Handler的构造方法是不是感觉很轻松?那就好.....之前那么长的铺垫没有白费,如果还不懂,再结合者前面的讲解看几遍.总结下,当实例化一个Handler的时候,这个handler会获得主线程中的Looper对象,和Looper中的成员变量mQueue，好了,所有的拼图碎片已经筹齐我们开始拼图了.我们平常实例化了Handler是不是就可以使用它的sendMessage方法呢？我们看看sendMessage到底干了什么，它其实调用了一个sendMessageAtTime()方法.
public boolean sendMessageAtTime(Message msg, long uptimeMillis)
{
boolean sent = false;
MessageQueue queue = mQueue;
if (queue != null) {
msg.target = this;
sent = queue.enqueueMessage(msg, uptimeMillis);
}
else {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
}
return sent;
}
哦.... 相信大家已经能明白了.
首先msg.target = this;是不是很熟悉,我帮你们回忆一下.在Looper的looper的讲解中,第四个重点.
msg.target.dispatchMessage(msg)
是不是有种醍醐灌顶的感觉.这下所有的拼图组成一张图了,从这句核心代码就明白了,主线程Looper负责把所有的Message分发给相对应的handler来处理,然后把这个Message再次放入队列.而target就是指的Handler.最后指定的Handler的HandleMessage来处理这个消息,
这个就是整个Handler和Looper工作的流程....