Handler在我刚做开发时就接触过，但是当时对其与Looper，MessageQueue，Thread之间的关系非常模糊。我觉得很多Android开发者，尤其是初学者，对Handler的原理都不是很清楚。由于最近的项目中使用Handler比较多，所以对其原理进行了较深的研究。那么就写篇博客来总结一下Handler的原理，然后写了一个项目实例应用Handler，这个实例中使用了多个线程进行通信，这样自己的整体思路才能更清楚点，也发现了不足的地方。
不管三者之间的关系有多复杂，其总体思路是：Looper源源不断的从MessageQueue中取出Message，然后Handler来处理该Message。
handler的两个功能：处理Message和将某个Message添加到MessageQueue中。
1.处理Message
与处理Message相关的函数有
public void dispatchMessage(Message msg); //对Message进行分发
public void handleMessgae(Message msg);//对Message进行处理public static void loop(){
final Looper me=myLooper();//获得Looper对象
...
final MessageQueue queue=me.mQueue();//获取Looper中与之唯一对应的MessageQueue
...
for(;;){//不断进行循环处理
Message msg=queue.next();//取出队列中的下一个消息
if(msg==null) return;
...
msg.target.dispatchMessage(msg);
...
msg.recycle();//消息处理完成后，进行回收
}
}上述代码中核心的一句是：msg.target.dispatchMessage(msg) 。Message对象中保存了处理它的Handler的引用，这样就可以调用该Handler的dispatchMessage(msg)函数来分发消息Message了。
Handler内部的分发流程是这样的：
1.Message.callback(Runnable对象)是否为空，若不为空，优先执行Runnable。否则执行步骤2。
2.mHandler.mCallback是否为空，若不为空，优先执行mCallback。否则执行步骤3。
3.在Message.callback(Runnable对象)和mHandler.mCallback均为空的情况下，再执行mHandler.handleMessage(msg);
我们可以在创建Handler时重载handleMessage来实现我们自己处理Messgae的过程。
2.将某个Message添加到MessageQueue中
刚开始我也不清楚为什么Handler要处理Message但又把Message加到消息队列MessageQueue中。其实这样做的目的是保证处理的有序性，把所要需要处理的Message添加到消息队列中，之后再一个一个从消息队列中取出处理。
那Handler是如何将Message添加到MessageQueue中的呢？相应的函数有下面两种：Post系列和Send系列。
Post系列：
final boolean post(Runnable r); //将一个Runnable对象包装成Message后加入到消息队列中
final boolean postAtTime(Runnable r, long uptime);//将一个Runnable对象包装成Message后，在指定的时间添加到消息队列中Send系列：
final boolean sendEmptyMessage(int what) ;//发送类型为what的Message，该Message会有handleMessage(msg)来处理。
final boolean sendMessageAtFrontOfQuene(Message msg);
final boolean sendMessageAtTime(Message msg, long uptimeMillis); //在指定时间将Message添加到消息队列中。
final boolean sendMessageDelayed(Message msg, long delayMillis) ;//延长delayMillis时间后在发送Message，其内部的实现是：计算出发送时 间=当前时间+延长时间delayMillis，然后再调用sendMessageAtTime首先来看一下Post和Send的区别：post的参数是Runnable，也就是可执行的线程。而send系列的参数则为Message消息。post内部会将Runnable包装成Message形式。
那么如果封装呢？先看一下Message的内部属性。
public final class Message implements Parcelable{
public int what;
public int arg1;
public int arg2;
public Object obj;
....
Handler target; //处理该Message的Handler
Runnable callback;//回调
}public final boolean post(Runnable r){
return sendMessageDelayed(getPostMessage(r),0);
}
private static Message getPostMessage(Runnable r){
Message m=Message.obtain();//从Message池中获取一个Message,这样可以避免资源浪费
m.callback=r;
return m;}Looper内部有一个MessageQueue消息队列，Looper就像一个发动机，驱动着整个程序的运行。
在整个系统中Handler，Looper，MessageQueue，Message的对应关系如下：
1.每个Thread只对应着一个Looper；
2.每个Looper只对应着一个MessageQueue；
3.每个MessageQueue中可以有多个Message；
4.每个Message最多对应一个Handler。
看一下Looper创建MessageQueue的源码：
final MessageQueue mQueue;
//Looper的构造函数
private Looper(boolean quitAllowed){
mQueue=new MessageQueue(quitAllowed);
....
}
下面来介绍两种线程：普通线程和主线程ActivityThread（也叫UI线程）
普通线程：
也就是说我们自己创建一个Thread，然后创建Handler和Looper，并建立他们之间的关系。
步骤有三个：1.Looper的准备工作(prepare)；
2.Handler的创建；
3.Looper开始运转。
class MyLooperThread extends Thread{
public Handler mHandler;
public void run(){
Looper.prepare();
mHandler=new Handler(){
public void handleMessage(Message msg){
switch(msg.what){
case 0:
Log.i(TAG,"MyLooperThread.Handler is handling Message");
break;
}
}
};
Looper.loop();
}
}使用该线程中的Handler：
MyLooperThread myThread=new MyLooperThread();
myThread.start();
myThread.mHandler.sendEmptyMessage(0);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));
}static final ThreadLocal<Looper> sThreadLocal =new ThreadLocal<Looper>();接着研究执行new Handler()时，是如何将该Handler绑定到该Thread和Looper的。
Handler的构造函数有下面几种：
public Handler();
public Handler(Callback callback);
public Handler(Looper looper);
public Handler(Looper looper,Callback callback);public class Handler{
...
final MessageQueue mQueue;
final Looper mLooper;
final Callback mCallback;
final boolean mAsynchronous;
...
}public Handler() {
this(null, false);
}
public Handler(Callback callback, boolean async) {
...
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;
mAsynchronous = async;
}UI主线程：ActivityThread
下面是一个在UI主线程中使用Handler的Demo。
public class MainActivity extends ActionBarActivity {
public final static String TAG="MianActivity";
private Handler mHandler=new Handler(){
public void handleMessage(Message msg){
super.handleMessage(msg);
switch(msg.what){
case 0:
Log.i(TAG, "Message.what=0");
break;
case 1:
Log.i(TAG, "Message.what=1");
break;
}
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mHandler.sendEmptyMessage(0);
mHandler.post(new Runnable(){
@Override
public void run() {
Log.i(TAG, "This is a new Runnable");//可能会引起线程堵塞
}
});
}
}UI主线程中的Handler经常用于UI的更新，普通线程我在项目中的应用是后台线程进行一些配置文件的下载，网络请求等，其中的Handler用于线程之间的通信。其实Android为我们提供了一种简便的普通线程使用Handler：HandlerThread。Android关于该类的描述：
Handy class for starting a new thread that has a looper. The looper can then be used to create handler classes. Note that start() must still be called.1.线程的创建和开始；
HandlerThread myThread=new HandlerThread("Thread_name");
myThread.start();Looper myLooper=myThread.getLooper();Handler mHandler=new Handler(myLooper){
public void handleMessage(Message msg){
}
};下面结合一个实际项目工程：在程序启动后创建一个后台工作线程，来完成用户的登录和配置文件的下载，并通过Handler来完成线程之间的通信，实现对UI的更新。
package com.example.testhandler;
import java.io.File;
import android.support.v7.app.ActionBarActivity;
import android.widget.TextView;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Message;
public class MainActivity extends ActionBarActivity {
public static final String TAG="MianActivity";
public static final int READY_LOGIN=0x0001;//准备登录
public static final int ON_LOGIN=0x0002;//正在登录
public static final int DOWNLOAD_CONFIG=0x0003;//下载配置文件
public static final int SUCCESS_LOGIN=0x0004;//登陆成功
private TextView text;//显示当前工作状态
private String userAccount;//用户账号
private String userPassword;
private HandlerThread m_workThread;
private Handler m_workHandler;
//UI主线程的Handler:更新UI
private Handler mHandler=new Handler(){
public void handleMessage(Message msg){
super.handleMessage(msg);
switch(msg.what){
case DOWNLOAD_CONFIG:
text.setText("下载配置文件中...");
break;
case ON_LOGIN:
text.setText("正在登陆中...");
break;
case SUCCESS_LOGIN:
text.setText("完成登录");
}
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
text=(TextView)findViewById(R.id.text);
//创建并启动后台工作线程
m_workThread=new HandlerThread("workThread");
m_workThread.start();
//将m_workThread线程的Loop和MessageQueue关联到Handler
m_workHandler=new Handler(m_workThread.getLooper()){
@Override
public void handleMessage(Message msg){
super.handleMessage(msg);
switch(msg.what){
case READY_LOGIN:
//准备登录包括：用户账号获取和配置文件的下载
userAccount="123456";
userPassword="123456";
File file=new File(MainActivity.this.getFilesDir()+"/baseconfig.xml");
if(!file.exists()){
//配置文件不存在，UI提示正在下载配置文件，再创建一个线程来下载文件
mHandler.obtainMessage(DOWNLOAD_CONFIG).sendToTarget();
downloadConfig();
}
break;
case ON_LOGIN:
mHandler.sendMessage(mHandler.obtainMessage(ON_LOGIN));//更新UI
startLogin(userAccount,userPassword);
break;
case SUCCESS_LOGIN:
mHandler.sendMessage(mHandler.obtainMessage(SUCCESS_LOGIN));//更新UI
break;
}
}
};
//在后台工作线程中完成登录过程
m_workHandler.obtainMessage(READY_LOGIN).sendToTarget();
}
private void downloadConfig(){
//启动一个新的线程下载配置文件
new Thread(){
@Override
public void run(){
//...这里进行一系列Http请求完成下载
try {
sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
m_workHandler.sendMessage(m_workHandler.obtainMessage(ON_LOGIN));//完成下载后通知后台线程开始登陆
}
}.start();
}
private void startLogin(String account,String password){
//...这里完成Socket登陆过程
new Thread(){
public void run(){
try {
sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//完成后更新UI
m_workHandler.sendMessage(m_workHandler.obtainMessage(SUCCESS_LOGIN));
}
}.start();
}
}View.post(Runnable action)
Runable中的run方法是在UI线程中执行的，Runable不一定是新开了一个线程执行。该函数的工作原理如下：
在View的post方法中获得UI线程的一个Handler，将该Rnnable包装成Message添加到MessageQueue中。
2357
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
