android 之 Handler 详解----（一）实现的消息传递基本原理（流程分析）

Handler可以说是android 中必需掌握的一个点，是android 提供的一套完整的消息传递的机制。我们常见的有用于 UI 的更新。

近来对相关的源代码以及使用进行了了解，记录以下几点：

（一）实现的基本原理

（二）常见的使用的基本方式

（三）更新UI的方法

（一）实现的消息传递基本原理（流程分析）

Handler 实现的离不开Looper 以及 MessageQueue,总结来说是：

1.Handler负责消息的发送，Looper负责接收Handler发送的消息，并且直接回传给Handler自己来处理消息。

2.Looper创建的时候会关联一个MessageQueue 的一个存储消息的容器，负责消息的存储。

以下是以main 线程（UI线程）的handler 以及 Looper为例，讲解一下handler消息是如何传递的。

主要的流程如下：

线程创建-----> Looper的创建 ----> handler 与 Looper的关联----->handler 发送消息----->通过Looper以及messageQueue----->回传给自己handler自己处理消息。

下面是详细的流程讲解：

（首先看看以下简单的handler的使用代码）

<例子>

public class MainActivity extends Activity {

//UI线程中的handler处理
private Handler handler = new Handler(){
public void handleMessage(android.os.Message msg) {
if (msg.what == 1) {
System.out.println("main thread-----UI thread");
}
};
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//子线程
new Thread(){
@Override
public void run() {
Message msg = new Message();
msg.what = 1 ;
//通过主线程的handler对象，发消息回自己处理
handler.sendMessage(msg);
}
}.start();
}
}

在一个线程中，使用handler 必须要创建相关联的 Looper 来一起使用，不然系统会抛出异常。那为什么在main线程（UI线程）中没有Looper的相关操作呢？其实在main线程（UI线程）在其创建的时候，就已经对looper进行的操作，我们在源代码中查看一下：

<A> . ActivityThread.java中的main函数如下：

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();

主线程在在创建的时候，其中的main方法调用的时候，已经对Looper进行了关联，下面我们跟踪进

入Looper.prepareMainLooper，进入到prepareMainLooper，里面，发现里面有个prepare 方法，以下是prepare()方法的具体代码：

< B > Looper.java

public static void prepare() {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper();
}
public static void prepareMainLooper() {
prepare();
setMainLooper(myLooper());
myLooper().mQueue.mQuitAllowed = false;
}
private synchronized static void setMainLooper(Looper looper) {
mMainLooper = looper;
}

在进入looper之中，prepare方法新建了一个 Looper ，然后后面给了mMainLooper,这个时候main线程中的Looper已经准备好了，准备好了，后面就可以使用了。

而在 new Looper（）中，还创建了一个MessageQueue:

private Looper() {
mQueue = new MessageQueue();
mRun = true;
mThread = Thread.currentThread();
}

到此为止，UI线程中已经建立了Looper 以及messageQueue了。

在我们的事例代码中，有中new Handler的操作，深入源代码中，查找，里面会发现，里面就是和相应的Looper进行了关联，也关联相关的MessageQueue，Handler中的构造函数：

< C > Handler.java

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 = null;

<例子>中UI线程新建一个handler 的操作，实际也和Looper而进行了关联，然后在oncreate中新建一个线程，通过handler中的sendMessage()方法进行消息的发送操作，下面就开始看看，消息是如何发送回来 handler自身的。

< D >... Handler.java MessageQueue.java

public final boolean sendMessage(Message msg)
{
return sendMessageDelayed(msg, 0);
}

public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}

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;
}

消息已经保存到了MessageQueue中去了，然后Looper的作用就开始了，Looper就是要把MessageQueue中的消息轮询的方式发送出去，
往回看一下 <A> 中的代码，最后的时候，调用了 Looper.loop()，这个作用到底是什么呢？没错，这个就是Looper要传消息了，我们深入看看其中的代码：

<E> Looper.java

public static void loop(){
Looper me = myLooper();
...
MessageQueue queue = me.mQueue;

...

while (true) {
Message msg = queue.next(); // might block
if (msg != null) {
...

msg.target.dispatchMessage(msg);

...

msg.recycle();
}
}
}

上面的代码重点在 轮询 messageQueue里面的message ，然后就是调用msg.target.dispatchMessage(msg), 这个就会发现这个消息回传到了UI线程中的handler了


<F> Handler.java

public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}

这个时候，消息就重新发回到handler自身的handleMessage 方法中了，消息大功告成的传了回来。

上面是叙述了UI线程中的handler消息的回传的流程，一样的如果我们需要在一个新建的线程中，创建一个handler 来接收其他线程或者UI线程传过来的消息，必须对 Looper进行操作，Looper.prepare()以及Looper.loop（）的操作，不然与这个线程不能关联到。UI线程中，只是预先帮我们做了。 当然其实还有另外的方法不用我们自己手动进行，而且可以更加的安全，那个就是HandlerThread，这个后续我关于Handler的使用的帖子，对此进行记录，我的学习状态。

原创，如需转载请标明出处，谢谢~