还记得第一次使用Handler的情形，我开启了一个子线程，在子线程中给TextView进行setText()，然后运行起来程序异常终止了，查看log信息：
E/AndroidRuntime(2206): android.view.ViewRootImpl$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.
goolgle一下找到了原因: 原来android中相关的view和控件不是线程安全的，我们必须单独做处理。然后就了解了Handler。可以在子线程中通过Handler发送一个Message给主线程，然后在主线程进行UI更新
可以大概看成Handler的作用有分发消息，处理消息，发送消息，移除消息
下面看一下Message类
可见Message包括what(message的标识) 、obj 任意对象， arg1 arg2, 而且可以设置Target来指定Handler
当Handler发送一条Message时有一下两种写法：
Message msg = Message.obtain(); msg.what = 200; msg.obj = obj; handler.sendMessage(msg);
Message.obtain(handler, 200).sendToTarget();
Looper类：
Looper的类注释中
Class used to run a message loop for a thread. Threads by default do not have a message loop associated with them; to create one, call prepare in the thread that is to run the loop, and then loop to have it process messages until the loop is stopped.
Most interaction with a message loop is through the Handler class.
This is a typical example of the implementation of a Looper thread, using the separation of prepare and loop to create an initial Handler to communicate with the Looper.
class LooperThread extends Thread {
public Handler mHandler;
public void run() {
Looper.prepare();
mHandler = new Handler() {
public void handleMessage(Message msg) {
// process incoming messages here
}
};
Looper.loop();
}
}
Handler的作用？
1)在非UI线程更新UI ;2)发送一个延时消息;
3)当做定时器，每隔一段时间发送一次消息，如进行图片轮播
为什么android设计只能UI线程更新UI？
1) 解决多线程并发的问题2) 提高界面更新的性能问题
3) 架构设计的简单
Handler 相关的异常
1)E/AndroidRuntime(2206): android.view.ViewRootImpl$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.
不能子线程更新UI的异常{解决：在子线程向主线程中的handler发送Message}
2E/AndroidRuntime(2329): java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()
不能在子线程中new Handlder()，我们需要调用Looper.prepare(); 后new Handler然后 Looper.loop();
我们自己创建的线程中没有Looper对象，这里注意一点，在ActivityThread线I程中会隐士的调用Looper.prepare（）方法
在下面我们会看一下Looper.prepare()方法的源码
Handler、Looper、MessageQueue之间的关系（源码角度分析）？
Handler 的构造方法：
/**
* Use the {@link Looper} for the current thread with the specified callback interface
* and set whether the handler should be asynchronous.
*
* Handlers are synchronous by default unless this constructor is used to make
* one that is strictly asynchronous.
*
* Asynchronous messages represent interrupts or events that do not require global ordering
* with represent to synchronous messages. Asynchronous messages are not subject to
* the synchronization barriers introduced by {@link MessageQueue#enqueueSyncBarrier(long)}.
*
* @param callback The callback interface in which to handle messages, or null.
* @param async If true, the handler calls {@link Message#setAsynchronous(boolean)} for
* each {@link Message} that is sent to it or {@link Runnable} that is posted to it.
*
* @hide
*/
public Handler(Callback callback, boolean async) {
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());
}
}
//获取Looper
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue; //获取Looper中的MessageQueue
mCallback = callback;
mAsynchronous = async;
}</pre>Looper.myLooper();</div><div><pre name="code" class="java"> /**
* Return the Looper object associated with the current thread. Returns
* null if the calling thread is not associated with a Looper.
*/
public static Looper myLooper() {
return sThreadLocal.get();
}final MessageQueue mQueue;
而Handler的各种sendMessage方法最终都会调用sendMessageAtTime(Message msg, long uptimeMillis)
/**
* Enqueue a message into the message queue after all pending messages
* before the absolute time (in milliseconds) <var>uptimeMillis</var>.
* <b>The time-base is {@link android.os.SystemClock#uptimeMillis}.</b>
* Time spent in deep sleep will add an additional delay to execution.
* You will receive it in {@link #handleMessage}, in the thread attached
* to this handler.
*
* @param uptimeMillis The absolute time at which the message should be
* delivered, using the
* {@link android.os.SystemClock#uptimeMillis} time-base.
*
* @return Returns true if the message was successfully placed in to the
* message queue. Returns false on failure, usually because the
* looper processing the message queue is exiting. Note that a
* result of true does not mean the message will be processed -- if
* the looper is quit before the delivery time of the message
* occurs then the message will be dropped.
*/
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
MessageQueue queue = mQueue;
if (queue == null) {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
return false;
}
return enqueueMessage(queue, msg, uptimeMillis); //将msg入队到mQueue中
} private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}消息入队时将msg.target 制定成this，也就是Handler自身
Looper的构造方法： 可以看成这里会new一个MessageQueue对象，然后mThread为当前线程
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}Looper. prepare()方法，因为Looper的构造方法是私有，Handler调用mThreadLocal.get()方法来获得Looper对象，而Looper的prepare方法中会new一个Looper放到mThreadLocal中
/** Initialize the current thread as a looper. 初始化一个looper
* This gives you a chance to create handlers that then reference 该方法提供给用户一个机会去创建handler来
* this looper, before actually starting the loop. Be sure to call
* {@link #loop()} after calling this method, and end it by calling
* {@link #quit()}.
*/
public static void prepare() {
prepare(true);
}
private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(quitAllowed));
}
我们查看Looper的Loop方法
/**
* Run the message queue in this thread. Be sure to call
* {@link #quit()} to end the loop.
*/
public static void loop() {
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final 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();
for (;;) {//一个死循环
Message msg = queue.next(); // might block //不断获取下一个Message
if (msg == null) { //当队列为空时msg为null 跳出循环
// No message indicates that the message queue is quitting.
return;
}
// This must be in a local variable, in case a UI event sets the logger
Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
msg.target.dispatchMessage(msg); //这里调用msg.target（也就是handler）的<span style="font-family: Arial, Helvetica, sans-serif;"></span>dispatchMessage(msg);
if (logging != null) {
logging.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(TAG, "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.recycleUnchecked();
}
}
这里调用msg.target（也就是handler）的dispatchMessage(msg); 我们来看handler的dispatchMessage方法
/**
* Handle system messages here.
*/
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}可以看到最终会回调执行我们熟悉的 handleMessage(msg);
1).Looper 内部包含一个消息队列 MessageQueue，suoyoudeHandler发送的消息都走向这个消息队列Looper.Looper方法，一个死循环，不断从MessageQueue取消息，有消息就处理，没有就阻塞
2).MessageQueue一个消息队列，可以添加消息，并处理消息3).Handler Handler封装了消息的发送（主要包括消息发送的对象，如何处理）内部跟Looper相关联，也就是说在handler的内部可以找到Looper然后可以获得Message，在Handler中发送消息，其实是向MessageQueue队列中发送消息
总结：handler负责发送消息，Looper负责接受Handler发送来的消息，并把消息回传给handler自己，MessageQueue是一个存储消息的容器
结合图片看看这个过程