Android-Handler的消息传递机制

最近在翻看李刚的《疯狂android讲义》发现对handler讲解比较容易入门，就总结一下：

大家都知道Android为了保证线程安全制定了一条规则：只允许UI线程修改activity里的UI组件；而当一个程序第一次启动时，Android会同时启动一条主线程(Main Thread)，主线程主要负责处理与UI相关的事件，所以主线程又叫UI线程。

假如我们想要多个线程来操作UI组件，Android也提供了另外一种方式，利用Handler的消息传递机制，发送消息给UI线程，然后在UI线程中处理Handler发送过来的消息，从而解决多线程修改UI的问题。

先来看一段简单的利用Handler自动播放图片的实例代码：（Java代码）

public class HandlerActivity extends AppCompatActivity {
    private int[] imageIds = new int[]
            {R.mipmap.icon_background_home_thumb1,
                    R.mipmap.icon_background_home_thumb2,
                    R.mipmap.icon_background_home_thumb3,
                    R.mipmap.icon_background_home_thumb4,
                    R.mipmap.icon_background_home_thumb5,
                    R.mipmap.icon_background_home_thumb6,
                    R.mipmap.icon_background_home_thumb7};
    int currentImageId = 0;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_handler);
        final ImageView imgShow = (ImageView) findViewById(R.id.img_handler_show);
        final TextView imgShowName = (TextView) findViewById(R.id.tv_img_show_name);
        final Handler myHandler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                if (msg.what == 0x1233) {
                    //动态修改要显示的图片
                    imgShow.setImageResource(imageIds[currentImageId % mageIds.length]);
                    imgShowName.setText("image." + (currentImageId %imageIds.length+1));
                    currentImageId++;
                }
            }
        };
        //定义一个计时器，让该计时器周期性执行指定任务
        new Timer().schedule(new TimerTask() {
            @Override
            public void run() {
                //发送空消息
                myHandler.sendEmptyMessage(0x1233);
            }
        }, 0, 1200);
    }
}```

xml代码比较简单，只包含了一个ImageView和一个TextView，此处就不列出了；
运行效果如下图：


![Handler.gif](https://img.haomeiwen.com/i2502757/3c8708f3151a2448.gif?imageMogr2/auto-orient/strip)


以上代码是在主线程中创建了Handler,然后Handler会周期性的调用sendEmptyMessage()方法发送消息给主线程的MessageQueue，主线程中的Looper会轮询的从MessageQueue中取出消息，当取到Handler的消息后会发给Handler，然后Handler利用handleMessage()来处理此消息，以此来更改ImageView 中的图片；
我们来详细的了解一下Handler以及它的工作流程。

### Handler类的主要作用和包含的方法

##### Handler的主要作用
* 在新启动的线程中发送消息
* 在主线程中获取、处理消息

##### Handler的主要方法
* void handleMessage(Message msg)：处理消息的方法。通常用于被重写。
* final boolean hasMessages(int what)：检查消息队列中是否包含what属性为指定值的消息。
* final boolean hasMessages(int what, Object object)：检查消息队列中是否包含what属性为指定值且object属性为指定对象的消息。
* 多个重载的Message obtainMessage()：获取消息。
* sendEmptyMessage(int what)：发送空消息。
* final boolean sendEmptyMessageDelayed(int what, long delayMillis)：指定多少毫秒后发送空消息。
* final boolean sendMessage(Message msg)：立即发送消息。
* final boolean sendMessageDelayed(int what, long delayMillis)：指定多少毫秒后发送消息。

### Handler、Looper、MessageQueue的工作原理
先来看看Handler发送消息和处理消息的流程图：


![利用Handler修改UI线程流程图.png](https://img.haomeiwen.com/i2502757/68978901aa17d3f6.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

* Message：Handler接收和处理的消息对象；
* Handler：把消息(Message)发送给Looper管理的MessageQueue，并负责处理Looper分给它的消息；
* Looper：每个线程都只能有一个，它负责管理MessageQueue，会不断的从MessageQueue中取出消息，并将消息分给对应的Handler处理；（注：主UI线程中系统会初始化一个Looper）
* MessageQueue：由Looper负责管理，程序在创建Looper对象时，会在它的构造器中创建MessageQueue对象;MessageQueue采用先进先出的方式来管理其内的message；

在上面自动播放图片的实例中，因为系统已经为主UI线程初始化了一个Looper对象，所以我们可以直接创建Handler,然后就可发送、处理消息了，如果是在自己定义的子线程中，我们就必须自己创建一个Looper对象。

### 在自定义线程中使用Handler的步骤
1. 调用Looper的prepare()方法为当前自定义线程的Looper对象，创建Looper对象时，它的构造器会创建与之配套的MessageQueue。
2. 创建Handler子类的实例，重写handlerMessage()方法，该方法负责处理来自其他线程的消息。
3. 调用Looper的loop()方法启动Looper。

以下是使用新线程计算质数实例，其中包括主线程和新的子线程；先来看看运行效果：


![ThreadHandler.gif](https://img.haomeiwen.com/i2502757/261cc7d7952f332f.gif?imageMogr2/auto-orient/strip)


由于xml只包含EditText、TextView、Button三个基本控件，xml文件就不在列出，只上java代码：

public class ThreadHandlerActivity extends Activity {
private static final String UPPER_NUM = "upper";
private static final String RESULT = "result";
private EditText edit_number;
private TextView tv_calculate_result;
private CalThread calThread;
Handler mainHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
if (msg.what == 0x1234) {
tv_calculate_result.setText(msg.getData().getString(RESULT));
}
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_thread_handler);
edit_number = (EditText) findViewById(R.id.edit_number);
tv_calculate_result = (TextView) findViewById(R.id.tv_calculate_result);
calThread = new CalThread();
calThread.start();//启动新线程
findViewById(R.id.btn_calculate).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (TextUtils.isEmpty(edit_number.getText().toString().trim())) {
Toast.makeText(ThreadHandlerActivity.this, "请输入数字", Toast.LENGTH_SHORT).show();
} else {
Message msg = new Message();
msg.what = 0x123;
Bundle bundle = new Bundle();
bundle.putInt(UPPER_NUM, Integer.parseInt(edit_number.getText().toString().trim()));
msg.setData(bundle);
//向新线程中的Handler发送消息
calThread.mHandler.sendMessage(msg);
}
}
});
}
private class CalThread extends Thread {
public Handler mHandler;
@Override
public void run() {
Looper.prepare();//为当前线程创建Looper实例以及配套的MessageQueue，然后才能创建Handler
mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
if (msg.what == 0x123) {
int upper = msg.getData().getInt(UPPER_NUM);
List<Integer> nums = new ArrayList<>();
//计算从2开始，到upper的所有质数
outer:
for (int i = 2; i <= upper; i++) {
//用i除以从2开始，到i的平方根的所有数
for (int j = 2; j <= Math.sqrt(i); j++) {
//如果可以整除，则表明这个数不是质数
if (i != 2 && i % j == 0) {
continue outer;
}
}
nums.add(i);
}
Message msg1 = new Message();
msg1.what = 0x1234;
Bundle bundle = new Bundle();
bundle.putString(RESULT, nums.toString());
msg1.setData(bundle);
mainHandler.sendMessage(msg1);
}
}
};
Looper.loop();//启动Looper
}
}
}```

其实计算质数还有更加简单的方法，利用AsyncTask来进行实现。

参考文章

• 《疯狂android讲义》(第3版)第3章3.5Handler消息传递机制