Android进阶——强大的异步不可或缺的组件Handler详解(一)
从一开始开通博客就计划一周至少写两篇博客，把自己的以前记在本地下的知识点和经验，全部搬到自己的博客里，无论是复杂难易程度只要是自己想写的就搬到这里来，好好总结下形成自己的技术体系，因为有些东西不用就会一时之间想不起来了。ORZ…好了进入正题，对于Java开发来说Thread比较简单，直接匿名创建重写run方法，调用start方法执行即可。或者从Runnable接口继承，但对于Android来说在底层UI操作部分代码没有设计成为线程安全类型，所以需要引入一些同步的机制来实现线程间的通信使其刷新。Handler就是在这样的设计背景下应运而生。
一Handler概述
Handler跟多线程，消息队列联系很紧密，其主要的功能就是发送和处理Message，也可以分发Runnable对象。每个Handler实例，都会绑定到创建他的线程中(默认是位于主线程，但是我们可以通过Looper对象来指定到其他线程)。
二Handler的作用
执行计划任务，比如在预定的实现某些任务，模拟定时器等等。
线程之间的互相通信，在app启动的时候，会创建一个主线程（即UI线程），主线程创建了之后还会创建一个消息队列来处理各种消息，当我们创建了子线程时，可以在子线程中拿到主线程创建的Handler对象，当我们需要通信时就可以，通过该对象像主线程的消息队列发送消息，主线程接收到消息之后就会处理。
确保操作始终在某个特定的线程中运行。比如说当我们访问数据库并加载数据时，除了初始化要加载外，每当我们收到数据改变的消息通知时也需要重新加载，为了保证数据的有效性，减少不必要的查询操作。
三Handler机制重要的四种角色参与者的关系
一个消息循环的机制，简单来理解就是往消息队列里添加数据，然后异步的等待消息的返回。当消息队列为空的时候就会挂起线程，等待新的消息的加入。在线程里产生一个Looper对象，从字面上不难理解，可以看成在线程里一直循环运行，不断地检索MessageQueue，不断地取出消息，得到消息之后发送到Handler，这样Handler通过回调handleMessage方法就能处理消息了
Looper：Android的线程分为有消息循环的线程和没有消息循环的线程，有消息循环的线程一般都会有一个Looper。我们的主线程（UI线程）就是一个消息循环的线程。Looper的线程，不管是UI线程还是子线程，只要你有Looper，我就可以往你的消息队列里面添加东西，并做相应的处理。一句话每一个消息循环线程都可以产生一个Looper对象，用于管理线程里的MessageQueue
Handler:你可以构造Handler对象来于Looper沟通以便Push新的消息到MessageQueue里或者接收Looper（从MessageQueue中取出）发送过来的消息
MessageQueue:用于存放线程放入的消息
线程:产生Looper和MessageQueue
四得到Handler对象
默认的构造方法Handler()把当前Handler与当前线程和当前线程的消息队列绑定，这也是为什么默认的Handler一定运行在主线程中
可以触发回调Handler(Handler.Callbackcallback)
Handler(Looperlooper)把Handler绑定到Looper所属的线程和消息队列中
Handler(Looperlooper,Handler.Callbackcallback)
五Handler常用API
获取Looper对象：LoopergetLooper()
处理系统的消息：voiddispatchMessage(Messagemsg)一般不宜修改
处理消息：voidhandleMessage(Messagemsg)必须实现
从消息队列中得到新的Message对象：MessageobtainMessage()及重载
发送Runnable对象：booleanpost(Runnabler)及重载形式
发送消息：booleansendEmptyMessage()及重载
发送自定义Message：booleansendMessage(Messagemsg)
removeCallbacks(Runnabler)、removeCallbacksAndMessages(Objecttoken)、removeMessages(intwhat)等移除系列，移除了之后就不会去执行handleMessage(Messagemsg)
六Handler的简单应用
1同一个HandlerThread里可以有多个Handler
packagecmo.learn.mutiplethread;
importandroid.app.Activity;
importandroid.os.Bundle;
importandroid.os.Handler;
importandroid.os.Message;
importandroid.util.Log;
importandroid.view.View;
importandroid.widget.Button;
publicclassHandlerActivityextendsActivity{
privateHandlermainHandler1;
privateHandlermainHandler2;
ButtonmBtn1;
@Override
protectedvoidonCreate(BundlesavedInstanceState){
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_handler);
//在主线程中初始化Handler
mainHandler1=newHandler(){
@Override
publicvoidhandleMessage(Messagemsg){
super.handleMessage(msg);
Log.d("HandlerTest","主线程的Handler1对象接收到消息"+msg.what);
}
};
mainHandler2=newHandler(){
@Override
publicvoidhandleMessage(Messagemsg){
super.handleMessage(msg);
Log.d("HandlerTest","主线程的Handler2对象接收到消息"+msg.what);
}
};
}
publicvoidtestHandler(Viewview){
switch(view.getId()){
caseR.id.btn_handler01:
newThread(newRunnable(){
@Override
publicvoidrun(){
for(inti=0;i<10000;i++){
i++;
}
//mainHandler1.sendEmptyMessage(1);
mainHandler2.sendEmptyMessage(1);
}
}).start();
break;
caseR.id.btn_handler02:
break;
caseR.id.btn_handler03:
break;
default:
break;
}
}
}
运行结果：
当使用mainHandler1.sendEmptyMessage(1)发送消息时，mainHandler1接收到消息并处理
当使用mainHandler2.sendEmptyMessage(1)发送消息时，mainHandler2接收到消息并处理
2Handler创建到任意指定线程中
2.1直接在在新的线程中创建Handler和发送消息，这是不允许的
/运行时报java.lang.RuntimeException:Can''tcreatehandlerinsidethreadthathasnotcalledLooper.prepare()异常/
newThread(newRunnable(){
@Override
publicvoidrun(){
for(inti=0;i<1000;i++){
i++;
}
Handlerhandler=newHandler();//Handler放到当前新线程中
handler.sendEmptyMessage(3);
}
}).start();
2.2继承HandlerThread封装自己的HandlerThread，并且在HandlerThread.onLooperPrepared()方法中调用newHandler创建Handler对象并完成发送消息和回调处理
privateclassMyHandlerThreadextendsHandlerThread{
publicMyHandlerThread(Stringname){
super(name);
}
@Override
protectedvoidonLooperPrepared(){
super.onLooperPrepared();
for(inti=0;i<1000;i++){
i++;
}
Looperloop=this.getLooper();
newHandler(loop){
@Override
publicvoidhandleMessage(Messagemsg){
super.handleMessage(msg);
Log.d("HandlerTest",Thread.currentThread().getName()+"线程的Handler对象接收到消息"+msg.what);
}
}.sendEmptyMessage(3);
}
}
publicvoidtestHandler(Viewview){
switch(view.getId()){
caseR.id.btn_handler01:
//在新的线程中创建Handler和发送消息
newThread(newRunnable(){
@Override
publicvoidrun(){
for(inti=0;i<1000;i++){
i++;
}
Handlerhandler=newHandler();//Handler放到当前新线程中
handler.sendEmptyMessage(3);
}
}).start();
break;
caseR.id.btn_handler02:
MyHandlerThreadmyThread=newMyHandlerThread("子线程");//调用
myThread.start();
break;
default:
break;
}
}
3利用Handler(Looperloop)指定Handler运行的线程
3.1使用Looper.getMainLooper()
caseR.id.btn_handler02:
/MyHandlerThreadmyThread=newMyHandlerThread("子线程");
myThread.start();/
//使用MainLooper来指定
newThread(newRunnable(){
@Override
publicvoidrun(){
Handlerhandler;
handler=newHandler(Looper.getMainLooper()){
@Override
publicvoidhandleMessage(Messagemsg){
super.handleMessage(msg);
Log.d("HandlerTest",Thread.currentThread().getName()+"的Handler对象接收到消息"+msg.what);
}
};
handler.sendEmptyMessage(4);
}
}).start();
3.2使用Looper.prepare()和Looper.loop()
//使用Looper.prepare()和Looper.loop()来指定运行的线程
newThread(newRunnable(){
@Override
publicvoidrun(){
Handlerloophandler;
Looper.prepare();//必须执行
loophandler=newHandler(){
@Override
publicvoidhandleMessage(Messagemsg){
super.handleMessage(msg);
Log.d("HandlerTest",Thread.currentThread().getName()+"的Handler对象接收到消息"+msg.what);
}
};
loophandler.sendEmptyMessage(5);
Looper.loop();
}
}).start();
通过以上两个小实验，我们可以知道，通过指定Looper对象，我们就可以控制Handler运行在指定的线程。
4同一个Handler中不同的消息不可能同时执行，也不会交替执行
首先封装我们自己的一个Handler来处理两条消息
privateclassProcessMessageHandlerextendsHandler{
publicProcessMessageHandler(Looperlooper){
super(looper);
}
@Override
publicvoidhandleMessage(Messagemsg){
super.handleMessage(msg);
Log.d("HandlerTest","Start：ProcessMessageHandler对象接收到第一条消息"+msg.what);
try{
Thread.sleep(5000);//阻塞5秒，是为了避免UI被阻塞，把Handler放到了另外的线程
}catch(Exceptione){
e.printStackTrace();
}
Log.d("HandlerTest","End：ProcessMessageHandler对象接收到第二条消息"+msg.what);
}
}
模拟同时发送两条信息
HandlerThreadthreadProcess=newHandlerThread("Process");
threadProcess.start();//启动HandlerThread
Hanwww.shanxiwang.netdlerhandlerProcess=newProcessMessageHandler(threadProcess.getLooper());
handlerProcess.sendEmptyMessage(6);//发送两条消息，每条消息都执行6s
handlerProcess.sendEmptyMessage(7);
运行结果：
两条消息之间是不可能出现交替处理的，只有我们处理完一条消息之后，才会再从MessageQueue中读取下一条消息。
5对于我们正在执行的Message，我们能否Remove掉？
5.1Remove掉一个还没有开始执行的Message
首先还是先启动一条HandlerThread
privateHandlerworkMsgHandler;
HandlerThreadworkingMsgThread=newHandlerThread("WorkingMsg");
workingMsgThread.start();
workMsgHandler=newProcessMessageHandler(workingMsgThread.getLooper());
发送消息
workMsgHandler.sendEmptyMessage(10);//发送消息
workMsgHandler.sendEmptyMessage(12);//发送消息
执行Remove：
workMsgHandler.removeMessages(12);//5S前移除消息what为12
运行结果对比：
未移除what为12的消息：
移除了what为12的消息：
5.2Remove掉一个正在执行的Message
首先还是先启动一条HandlerThread
privateHandlerworkMsgHandler;
HandlerThreadworkingMsgThread=newHandlerThread("WorkingMsg");
workingMsgThread.start();
workMsgHandler=newProcessMessageHandler(workingMsgThread.getLooper());
发送消息之后
workMsgHandler.sendEmptyMessage(10);//发送消息
马上执行移除消息
workMsgHandler.removeMessages(10);//5S前移除消息what为10
运行结果：
很明显无法Remove掉正在执行的Message，如果呗Remove掉的话“End……”就不会被打印
5.3小结
一旦Message已经被执行，在执行的过程中不会被Remove掉；能Remove的只有未被执行的Message即Remove只能移除消息队列中的Message。
6同一个HandlerThread中使用多个Handler的MessageQueue不会混淆
7利用弱引用去封装自己的Handler
虽然在Android中已经不推荐使用WeakReference（防止内存泄漏，要保证内存被虚拟机回收，即弱引用关联的对象在JVM进行垃圾回收时总会被回收），甚至在高级版本中据说已经完全删除了弱引用，但是个人觉得若是用得恰当对自己开发的代码质量的提高有显著的效果。反之，则坑人坑己。anyway，慎用为妙。
通过弱引用得到Activity的对象，进而在封装的Handler中使用Activity的方法交互
staticclassMyHandlerextendsHandler{
privatefinalWeakReferencemAct;//声明弱引用
//声明构造方法供外部调用构MyHandler对象
publicMyHandler(MainActivityact){
mAct=newWeakReference(act);
}
@Ovrride
publicvoidhandleMessage(Messagemsg){
//在这里获取MainActivity的引用并强转，调用相关方法showMessage
((MainActivity)mAct.get()).showMessage();
}
}
使用自己封装的Handler发送消息
privateMyHandlerhandler=newMyHandler();
总结
Handler实例与消息处理是相关联的，发送和接收都要求匹配，只能依附在Handler线程或其子类中，所以Handler的所有操作都是在一个线程中。
|
|
