![[Android]Handler的消息机制](https://image.shishitao.com:8440/aHR0cHM6Ly9ia3FzaW1nLmlrYWZhbi5jb20vdXBsb2FkL2NoYXRncHQtcy5wbmc%2FIQ%3D%3D.png?!?w=700&webp=1 "[Android]Handler的消息机制")
最经面试中，技术面试中有一个是Handler的消息机制，细细想想，我经常用到的Handler无非是在主线程（或者说Activity）新建一个Handler对象，另外一个Thread是异步加载数据，同时当他加载完数据后就send到主线程中的那个Handler对象，接着Handler来处理，刚才发送的一些消息。
![[Android]Handler的消息机制](https://image.shishitao.com:8440/aHR0cDovL3N0YXRpYy5vcGVuLW9wZW4uY29tL2xpYi91cGxvYWRJbWcvMjAxMjA2MDYvMjAxMjA2MDYwODI2MjRfNjY0LnBuZw%3D%3D.png?w=700&webp=1 "[Android]Handler的消息机制")
public class HandlerTestActivity extends Activity {
private TextView tv;
private static final int UPDATE = 0;
private Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
// TODO 接收消息并且去更新UI线程上的控件内容
if (msg.what == UPDATE) {
// Bundle b = msg.getData();
// tv.setText(b.getString("num"));
tv.setText(String.valueOf(msg.obj));
}
super.handleMessage(msg);
}
};
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
tv = (TextView) findViewById(R.id.tv);
new Thread() {
@Override
public void run() {
// TODO 子线程中通过handler发送消息给handler接收，由handler去更新TextView的值
try {
for (int i = 0; i < 100; i++) {
Thread.sleep(500);
Message msg = new Message();
msg.what = UPDATE;
// Bundle b = new Bundle();
// b.putString("num", "更新后的值：" + i);
// msg.setData(b);
msg.obj = "更新后的值：" + i;
handler.sendMessage(msg);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}.start();
}
}
如图所示，每个Thread都一个Looper，这个Looper类是用于管理其中的消息队列（MessageQueue）的,那Handler是干嘛的呢，他是用来传递消息队列的。
那下面就分析Looper、Hanlder方法吧。
Looper方法是用来处理消息队列的，注意了，它和线程是绑定的。
要是想在子线程中获取一个Looper该怎么做呢：
Looper.prepare();
Looper looper = Looper.myLooper();
那么这些都干了哪些工作呢???
来看下它的源码吧:
Looper:
……
//准备Looper相关事宜
public static void prepare() {
//只能有一个对象哦
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper());
}
//构造函数
/*新建一个消息队列
* 把当前运行的线程作为运行线程
*/ private Looper() {
mQueue = new MessageQueue();
mRun = true;
mThread = Thread.currentThread();
}
public static final Looper myLooper() {
//这个方法是从当前线程的ThreadLocal中拿出设置的looper
return (Looper)sThreadLocal.get();
}
/**
* Run the message queue in this thread. Be sure to call
* {@link #quit()} to end the loop.
*/
public static void loop() {
Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
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 (msg != null) {
if (msg.target == null) {
// No target is a magic identifier for the quit message.
return;
} long wallStart = 0;
long threadStart = 0; // This must be in a local variable, in case a UI event sets the logger
Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
wallStart = SystemClock.currentTimeMicro();
threadStart = SystemClock.currentThreadTimeMicro();
} msg.target.dispatchMessage(msg); if (logging != null) {
long wallTime = SystemClock.currentTimeMicro() - wallStart;
long threadTime = SystemClock.currentThreadTimeMicro() - threadStart; logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
if (logging instanceof Profiler) {
((Profiler) logging).profile(msg, wallStart, wallTime,
threadStart, threadTime);
}
} // 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(TAG, "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();
}
}
}
下面就来看下Handler:
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());
}
}
//先获得一个Looper对象，这个要是在子线程里，是需要先prepare（）的
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;
}
/**
* Returns a new {@link android.os.Message Message} from the global message pool. More efficient than
* creating and allocating new instances. The retrieved message has its handler set to this instance (Message.target == this).
* If you don't want that facility, just call Message.obtain() instead.
会从消息池里面取得消息队列
*/
public final Message obtainMessage()
{
return Message.obtain(this);
}
那我现在写个小例子，是在子线程实现的消息的传递。
@Override
public void onClick(View v) {
int id = v.getId();
if (id == R.id.btn1) {
new Thread() { public void run() { Log.i("log", "run"); Looper.prepare();
// Looper looper = Looper.myLooper();
Toast.makeText(MainActivity.this, "toast", 1).show();
Handler h = new Handler() { @Override
public void handleMessage(Message msg) {
// TODO Auto-generated method stub
super.handleMessage(msg);
if (msg != null) {
String strMsg = (String) msg.obj;
System.out.println(strMsg);
} } };
//获取到Handler对象的消息
Message msg = h.obtainMessage();
msg.obj = "add";
msg.sendToTarget(); Looper.loop();// 进入loop中的循环，查看消息队列 }; }.start(); }
}
不知你是否理解，这个小Demo中，我们需要注意：
1 子线程也是可以有Handler的，其实Handler只是从当前的线程中获取到Looper来监听和操作MessageQueue的。
2 子线程需要先prepare（）才能获取到Looper的，是因为在子线程只是一个普通的线程，其ThreadLoacl中没有设置过Looper，所以会抛出异常，而在Looper的prepare（）方法中sThreadLocal.set(new Looper())是设置了Looper的。
而对于主线程里面的Handler，是没有以上的麻烦的，因为这个在Activity创建时，就已经初始化了Looper等其他工作了。
另外可以看下参考文章中的子线程中Toast。
参考文章：