本文深入剖析Android中Looper和Handler的工作原理，解释为何通过发送消息而非直接调用来执行函数，涉及消息循环、多线程处理及避免ANR错误的方法。
昨晚偷懒，这篇博客只写了一个标题，今天早晨一看，还有15的阅读量。实在是对不起那些同学.......换了是我，也会BS这样的LZ吧!sorry 啦
-------------------------------------------------------------------------------------------------------------------------------------------------------------
菜鸟我刚刚接触android源码的时候，当时连java语言都不太熟悉（菜鸟我一直是学C/C++），看到android某个应用的源码的时候，曾为这样的代码迷惑过。
private class MainHandler extends Handler {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case RESTART_PREVIEW: {
restartPreview();
if (mJpegPictureCallbackTime != 0) {
long now = System.currentTimeMillis();
mJpegCallbackFinishTime = now - mJpegPictureCallbackTime;
Log.v(TAG, "mJpegCallbackFinishTime = "
+ mJpegCallbackFinishTime + "ms");
mJpegPictureCallbackTime = 0;
}
break;
}
...
在同一个文件中不就是想调用restartPreview()函数吗？为什么不直接调用就好，还要发个消息然后在这个handleMessage()中来调用呢？初学菜鸟有没有同样的困惑？还是只有LZ一人太白痴了。
那么到底为什么要这么做呢。是为了异步，是为了多线程，将一些耗时的操作放到一个子线程里面去，大家应该知道如果在android的应用程序主线程，也就是UI线程里面如果执行耗时操作超过5s就会报ANR（application not respon）错误。所以，为了避免ANR，android应用程序将一些耗时操作放到一个独立的工作线程中去。
那么android是如何做到这点的呢？那个新的工作线程又是如何建立的？这就是android中Looper和Handler类的功劳。下面菜鸟来分析下首先看个类图：
从这个图看到Handler和HandlerThread类都有一个Looper成员变量。而且，Handler和Looper都有成员变量MessageQueue，下面我们看看Looper类和Handler类的作用。
Looper：
Looper类，来实现消息循环，内部有一个消息队列。看到Looper类的构造函数是private的，这样外部没法实例化Looper对象，Looper对象的构造只能通过Looper的内部接口，来看一段函数:
/** Initialize the current thread as a looper.
* This gives you a chance to create handlers that then reference
* 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 final void prepare() {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper());
}
/** Initialize the current thread as a looper, marking it as an application's main
* looper. The main looper for your application is created by the Android environment,
* so you should never need to call this function yourself.
* {@link #prepare()}
*/
public static final void prepareMainLooper() {
prepare();
setMainLooper(myLooper());
if (Process.supportsProcesses()) {
myLooper().mQueue.mQuitAllowed = false;
}
}看看，perpare()函数中，有这样一句话 sThreadLocal.set(new Looper());其中sThreadLocal是一个ThreadLocal类型的变量。ThreadLocal表示这是一个线程的局部变量，google之看到下面这段解释。
Implements a thread-local storage, that is, a variable for which each thread has its own value. All threads share the sameThreadLocal object, but each sees a different value when accessing it, and changes
made by one thread do not affect the other threads. The implementation supportsnull values.
菜鸟斗胆来翻译下，ThreadLocal实现了一种线程的局部存储，ThreadLocal代表一种线程局部变量，对于这种变量来说ThreadLocal保证每个线程都有一个独立的值(value)，所有线程都共有一个ThreadLocal对象，但是每个线程在访问这些变量的时候能得到不同的值，每个线程可以更改这些变量并且不会影响其他的线程。ThreadLocal支持NULL值。/*那位大牛有更好的翻译，分享下呗*/
其中ThreadLocal开放了两个接口：
public Tget()：获取调用线程的局部变量
public void set(T value) ：设置调用线程的局部变量
perpare()函数的这种处理方式保证在每个调用该函数的线程都有一个独立的Looper对象。
Handler：
Handler的作用是处理消息，他封装了消息的投递和对消息的处理。通过上面的图可以看到Handler类有一个Looper和MessageQueue成员变量，Handler类有4个不同的构造函数如下:
public Handler() {
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());
}
}
/*Handler默认的构造函数，使用当前线程（调用线程）的Looper对象给Handler成员变量mLooper赋值*/
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
/*使用当前线程（调用线程）的消息队列给Handler的mQueue赋值*/
mQueue = mLooper.mQueue;
mCallback = null;
}
/**
* Constructor associates this handler with the queue for the
* current thread and takes a callback interface in which you can handle
* messages.
*/
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;
/*跟默认构造函数差不多，只不过带了一个callback*/
mCallback = callback;
}
/**
* Use the provided queue instead of the default one.
*/
public Handler(Looper looper) {
/*使用指定的Looper来给Handler类的mLooper赋值*/
mLooper = looper;
mQueue = looper.mQueue;
mCallback = null;
}
/**
* Use the provided queue instead of the default one and take a callback
* interface in which to handle messages.
*/
public Handler(Looper looper, Callback callback) {
/*使用指定的Looper和CallBack来初始化Handler*/
mLooper = looper;
mQueue = looper.mQueue;
mCallback = callback;
}
可以看到Handler类的成员变量MessageQueue mQueue都会指向Looper类的的MessageQueue，Handler为什么要这么做呢？
下面看看Handler类提供那些接口：
sendEmptyMessage
public final Message obtainMessage(int what)
{
return Message.obtain(this, what);
}
/**
* 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);
}
}
/**
* Sends a Message containing only the what value.
*
* @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.
*/
public final boolean sendEmptyMessage(int what)
{
return sendEmptyMessageDelayed(what, 0);
}
/**
* Remove any pending posts of messages with code 'what' that are in the
* message queue.
*/
public final void removeMessages(int what) {
mQueue.removeMessages(this, what, null, true);
}
/**
*注意这个函数，函数将有子类实现
* Subclasses must implement this to receive messages.
*/
public void handleMessage(Message msg) {
}
public boolean sendMessageAtTime(Message msg, long uptimeMillis)
{
boolean sent = false;
MessageQueue queue = mQueue;
if (queue != null) {
/*看到Message的target变量指向当前这个Handler类*/
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指明了这个msg将有谁来处理，在这里msg.target=this，Handler类除了封装消息添加外还封装了消息处理的接口。
Looper和Handler的联系：
本菜鸟不才不知道上面的分析有没有错误，有没有让很多初学者犯迷糊，下面我将分析以下Looper和Handler类的联系，希望可以把上面的知识点串联起来。
当调用Looper类的loop()函数的时候当前线程就进入到一个消息循环中去。看看这个loop()@Looper.java函数先.
/**
* Run the message queue in this thread. Be sure to call
* {@link #quit()} to end the 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
);
/*下面的函数将Looper类和Handler类联系起来*/
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();
}
}
} 
其实这个Looper和Handler类中消息传递的机制还是很复杂到，用到了Linux中Pipe的相关知识，我太菜还不能做出更深的分析，以后有时间会好好学习下，在完善下这部份的知识。
好了，这篇blog就说到这里吧。下篇blog我会试着分析下，Handler和Looper的同步问题。届时会顺便学习一下HandlerThread类。
忘了说，如果哪位大牛发现我这篇blog有什么错误，敬请指正，免得误导了跟我一样的菜鸟
扫一扫
5639
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
