转载来源:
1. Android–多线程之Handler
2. android的消息处理机制(图+源码分析)——Looper,Handler,Message
3. java线程系列—Runnable和Thread的区别
4. Updating GUI: Runnables vs Messages
5. Handler初探
1. Android消息处理三个核心类
Android消息处理有三个核心类: Looper
, Handler
和Message
。 另外,Message Queue
(消息队列)被封装到Looper
里面,我们不直接使用MQ,不将其作为核心类。消息处理流程如下图所示:
1.1 Looper - 循环线程
- 每个线程有且最多只能有一个
Looper
对象,它是一个ThreadLocal
; Looper
内部有一个消息队列MQ,loop()方法调用后线程开始不断从队列中取出消息执行;Looper
使一个线程变成Looper线程;- android的主线程也是一个looper线程
使用Looper类创建Looper线程方法如下:
public class LooperThread extends Thread {
@Override
public void run() {
// 将当前线程初始化为Looper线程
Looper.prepare();
// ...其他处理,如实例化handler
// 开始循环处理消息队列
Looper.loop();
}
}
1.2 Handler - 消息传递
Class Overview
A
Handler
allows you to send and processMessage
andRunnable
objects associated with a thread’s MessageQueue. Each Handler instance is associated with a single thread and that thread’s message queue. When you create a new Handler, it is bound to the thread / message queue of the thread that is creating it – from that point on, it will deliver messages and runnables to that message queue and execute them as they come out of the message queue.
Handler
,它直接继承自Object,一个Handler
允许发送和处理Message
或者Runnable
对象,并且会关联到主线程的MessageQueue中。每个Handler具有一个单独的线程,并且关联到一个消息队列的线程,就是说一个Handler有一个固有的消息队列。当实例化一个Handler的时候,它就承载在一个线程和消息队列的线程,这个Handler可以把Message或Runnable压入到消息队列,并且从消息队列中取出Message或Runnable,进而操作它们。
Handler主要有两个作用:
- 在工作线程中发送消息
- 在UI线程中获取、处理消息
上面介绍到Handler
可以把一个Message对象或者Runnable对象压入到消息队列中,进而在UI线程中获取Message或者执行Runnable对象,所以Handler把压入消息队列有两大体系,Post
和 sendMessage
:
Post
Post允许把一个Runnable对象入队到消息队列中。它的方法有:
post(Runnable)
、postAtTime(Runnable,long)
、postDelayed(Runnable,long)
。sendMessage
sendMessage允许把一个包含消息数据的Message对象压入到消息队列中。它的方法有:sendEmptyMessage(int)
、sendMessage(Message)
、sendMessageAtTime(Message,long)
、sendMessageDelayed(Message,long)
。
从上面的各种方法可以看出,不管是post还是sendMessage都具有多种方法,它们可以设定Runnable对象和Message对象被入队到消息队列中,是立即执行还是延迟执行。
你可能会觉得Handler
能发两种消息,一种是Runnable
对象,一种是Message
对象,这是直观的理解,但其实post发出的Runnable
对象最后都被封装成Message
对象了,见源码:
// 此方法用于向关联的MQ上发送Runnable对象,它的run方法将在handler关联的looper线程中执行
public final boolean post(Runnable r)
{
// 注意getPostMessage(r)将runnable封装成message
return sendMessageDelayed(getPostMessage(r), 0);
}
private final Message getPostMessage(Runnable r) {
Message m = Message.obtain(); //得到空的message
m.callback = r; //将runnable设为message的callback,
return m;
}
public boolean sendMessageAtTime(Message msg, long uptimeMillis)
{
boolean sent = false;
MessageQueue queue = mQueue;
if (queue != null) {
msg.target = this; // message的target必须设为该handler!
sent = queue.enqueueMessage(msg, uptimeMillis);
}
else {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
}
return sent;
}
以下作具体说明:
Runnable / Post
对于Handler的Post方式来说,它会传递一个Runnable对象到消息队列中,在这个Runnable对象中,重写run()方法。一般在这个run()方法中写入需要在UI线程上的操作。
在Handler中,关于Post方式的方法有:
boolean post(Runnable r)
:把一个Runnable入队到消息队列中,UI线程从消息队列中取出这个对象后,立即执行。boolean postAtTime(Runnable r,long uptimeMillis)
:把一个Runnable入队到消息队列中,UI线程从消息队列中取出这个对象后,在特定的时间执行。boolean postDelayed(Runnable r,long delayMillis)
:把一个Runnable入队到消息队列中,UI线程从消息队列中取出这个对象后,延迟delayMills秒执行void removeCallbacks(Runnable r)
:从消息队列中移除一个Runnable对象。
下面通过一个Demo,讲解如何通过Handler的post方式在新启动的线程中修改UI组件的属性:
package com.bgxt.datatimepickerdemo;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
public class HandlerPostActivity1 extends Activity {
private Button btnMes1,btnMes2;
private TextView tvMessage;
// 声明一个Handler对象
private static Handler handler=new Handler();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.message_activity);
btnMes1=(Button)findViewById(R.id.btnMes1);
btnMes2=(Button)findViewById(R.id.btnMes2);
tvMessage=(TextView)findViewById(R.id.tvMessage);
btnMes1.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// 新启动一个子线程
new Thread(new Runnable() {
@Override
public void run() {
// tvMessage.setText("...");
// 以上操作会报错,无法再子线程中访问UI组件,UI组件的属性必须在UI线程中访问
// 使用post方式修改UI组件tvMessage的Text属性
handler.post(new Runnable() {
@Override
public void run() {
tvMessage.setText("使用Handler.post在工作线程中发送一段执行到消息队列中,在主线程中执行。");
}
});
}
}).start();
}
});
btnMes2.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
new Thread(new Runnable() {
@Override
public void run() {
// 使用postDelayed方式修改UI组件tvMessage的Text属性值
// 并且延迟3S执行
handler.postDelayed(new Runnable() {
@Override
public void run() {
tvMessage.setText("使用Handler.postDelayed在工作线程中发送一段执行到消息队列中,在主线程中延迟3S执行。");
}
}, 3000);
}
}).start();
}
});
}
}
有一点值得注意的是,对于Post方式而言,它其中Runnable对象的run()方法的代码,均执行在UI线程上,所以对于这段代码而言,不能执行在UI线程上的操作,一样无法使用post方式执行,比如说访问网络,下面提供一个例子,使用post方式从互联网上获取一张图片,并且显示在ImageView中。
package com.bgxt.datatimepickerdemo;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.util.EntityUtils;
import android.app.Activity;
import android.app.ProgressDialog;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Bundle;
import android.os.Handler;
import android.view.View;
import android.widget.Button;
import android.widget.ImageView;
public class HandlerPostActivity2 extends Activity {
private Button btnDown;
private ImageView ivImage;
private static String image_path = "http://ww4.sinaimg.cn/bmiddle/786013a5jw1e7akotp4bcj20c80i3aao.jpg";
private ProgressDialog dialog;
// 一个静态的Handler,Handler建议声明为静态的
private static Handler handler=new Handler();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.asynctask_activity);
btnDown = (Button) findViewById(R.id.btnDown);
ivImage = (ImageView) findViewById(R.id.ivSinaImage);
dialog = new ProgressDialog(this);
dialog.setTitle("提示");
dialog.setMessage("正在下载,请稍后...");
dialog.setCancelable(false);
btnDown.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// 开启一个子线程,用于下载图片
new Thread(new MyThread()).start();
// 显示对话框
dialog.show();
}
});
}
public class MyThread implements Runnable {
@Override
public void run() {
// 下载一个图片
HttpClient httpClient = new DefaultHttpClient();
HttpGet httpGet = new HttpGet(image_path);
HttpResponse httpResponse = null;
try {
httpResponse = httpClient.execute(httpGet);
if (httpResponse.getStatusLine().getStatusCode() == 200) {
byte[] data = EntityUtils.toByteArray(httpResponse
.getEntity());
// 得到一个Bitmap对象,并且为了使其在post内部可以访问,必须声明为final
final Bitmap bmp=BitmapFactory.decodeByteArray(data, 0, data.length);
handler.post(new Runnable() {
@Override
public void run() {
// 在Post中操作UI组件ImageView
ivImage.setImageBitmap(bmp);
}
});
// 隐藏对话框
dialog.dismiss();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
效果如下:
Message
见 1.3 Message
1.3 Message- 消息传递
由上可知,
Handler
发出的两种消息:Runnable
和Message
,Runnable
对象最后都被封装成Message
对象。
Handler
如果使用sendMessage的方式把消息入队到消息队列中,需要传递一个Message
对象,而在Handler中,需要重写handleMessage()方法,用于获取工作线程传递过来的消息,此方法运行在UI线程上。下面先介绍一下Message。
Message
是一个final类,所以不可被继承。Message封装了线程中传递的消息,如果对于一般的数据,Message
提供了getData()和setData()方法来获取与设置数据,其中操作的数据是一个Bundle对象,这个Bundle对象提供一系列的getXxx()和setXxx()方法用于传递基本数据类型的键值对,对于基本数据类型,使用起来很简单,这里不再详细讲解。而对于复杂的数据类型,如一个对象的传递就要相对复杂一些。在Bundle中提供了两个方法,专门用来传递对象的,但是这两个方法也有相应的限制,需要实现特定的接口,当然,一些Android自带的类,其实已经实现了这两个接口中的某一个,可以直接使用。方法如下:
- putParcelable(String key,Parcelable value):需要传递的对象类实现Parcelable接口。
- putSerializable(String key,Serializable value):需要传递的对象类实现Serializable接口。
还有另外一种方式在Message中传递对象,那就是使用Message自带的obj属性传值,它是一个Object类型,所以可以传递任意类型的对象,Message自带的有如下几个属性:
- int arg1:参数一,用于传递不复杂的数据,复杂数据使用setData()传递。
- int arg2:参数二,用于传递不复杂的数据,复杂数据使用setData()传递。
- Object obj:传递一个任意的对象。
- int what:定义的消息码,一般用于设定消息的标志。
对于Message对象,一般并不推荐直接使用它的构造方法得到,而是建议通过使用Message.obtain()这个静态的方法或者Handler.obtainMessage()获取。Message.obtain()会从消息池中获取一个Message对象,如果消息池中是空的,才会使用构造方法实例化一个新Message,这样有利于消息资源的利用。并不需要担心消息池中的消息过多,它是有上限的,上限为10个。Handler.obtainMessage()具有多个重载方法,如果查看源码,会发现其实Handler.obtainMessage()在内部也是调用的Message.obtain()。
2. Runnables
vs Messages
Stackoverflow: Updating-GUI: Runnables-vs-Messages
Messages can be reused, so it results in fewer objects created and less GC. You also end up with fewer classes and anonymous types.
One big advantage is that a class sending a Message to a Handler doesn’t need to know anything about the implementation of that Message. That can aid in encapsulation depending on where it’s used.
Lastly consider the difference in cleanliness between
mHandler.obtainMessage(DO_STUFF, foo).sendToTarget();
vs
final Foo tempFoo = foo;
mHandler.post(new Runnable(){
@Override
public void run(){
doStuff(tempFoo);
}
};
If you have several places where you would have to doStuff(), the former is MUCH more readable and you’ll have less code duplication.