Android Handler使用详解
handler是android给我们提供用来更新UI的一套机制，也是一套消息处理的机制，我们可以发送消息，也可以通过它处理消息。
它最根本的目的就是解决多线程并发问题，假设如果在一个Activity当中，有多个线程去更新UI，并且都没有加锁机制，就会产生更新界面错乱。如果对更新UI的操作都进行枷锁处理又会使应用性能下降，所以Android给我们提供了一套更新UI的机制，我们只需要遵循这样的机制就可以了，根本不用去关心多线程问题，多有的更新UI操作，都是在主线程的消息队列当中去轮询处理的。
handler的使用：
1、使用handler更新UI
详细参考：Android Handler使用详解之UI更新
定义handler
private Handler handler = new Handler();定义Runnable
Runnable runnable = new Runnable() {
public void run() {
tetxView.setText("cx");
}
};启动Runnable
handler.post(runnable);2、使用handler延时更新UI
前面相同，只有启动时有差别
handler.postDelayed(runnable, 2000);//延时2s更新UI延时发送通知
handler.sendEmptyMessageDelayed(what, 2000);3、使用handler消息传递
创建消息，可以创建不同类型的消息（这里arg1、arg2和obj）
Message message = new Message(); //或Message message = handler.obtainMessage();这是也可以用message.sendToTarget();发送消息
message.arg1=66;
message.arg2=33;
message.obj="cx";
handler.sendMessage(message);接收并处理消息
private Handler handler = new Handler(){
public void handleMessage(Message msg) {
tetxView.setText((String) msg.obj + msg.arg1 + msg.arg2);
};
};4、消息延时传递sendMessageDelayed，与上面相同。
5、handler移除功能
例如：在2中的延时更新UI过程中，在延时过程中移除，则UI不再更新。
handler.removeCallbacks(runnable);6、handler消息拦截
消息接收
private Handler handler = new Handler(new Callback() {
@Override
public boolean handleMessage(Message msg) {
// TODO Auto-generated method stub
Toast.makeText(getApplicationContext(), "1", 1).show();
return true;//返回false，执行完上面的代码在执行下面的；返回true，则不再执行下面的代码
}
}){
@Override
public void handleMessage(Message msg) {
// TODO Auto-generated method stub
Toast.makeText(getApplicationContext(), "2", 1).show();
}
};发送一个空消息
handler.sendEmptyMessage(1);
7、handler原理总结：
Handler负责发送消息，Looper负责接收Handler发送的消息，并直接把消息回传给handler自己，MessageQueue就是一个存储消息的容器。
8、创建与子线程相关的Handler
主线程的Handler中不要执行耗时操作，否则界面会出现卡死现象。
创建主线程Handler
private Handler handler = new Handler(){
public void handleMessage(android.os.Message msg) {
System.out.println("UI-----------"+Thread.currentThread());
};
};创建子线程和子线程Handler
class MyThread extends Thread{
public Handler handler;
@Override
public void run() {
// TODO Auto-generated method stub
Looper.prepare();//要创建handler必须先创建接收handler消息的Looper
handler=new Handler(){
public void handleMessage(android.os.Message msg) {
System.out.println("-----------"+Thread.currentThread());
};
};
Looper.loop();//开始循环Looper
}
};发送消息
MyThread thread=new MyThread();//定义子线程
thread.start();//启动子线程
thread.handler.sendEmptyMessage(1);//向子线程Handler发送消息
handler.sendEmptyMessage(1);//向主线程Handler发送消息9、HandlerThread
在主线程的Handler中传入子线程中定义的Looper时，会出现空指针问题。
定义子线程及子线程中的Handler和Looper
class MyThread extends Thread{
public Handler handler;
public Looper looper;
@Override
public void run() {
// TODO Auto-generated method stub
Looper.prepare();
looper=Looper.myLooper();
handler=new Handler(){
public void handleMessage(android.os.Message msg) {
System.out.println("-----------"+Thread.currentThread());
};
};
Looper.loop();
}
};启动子线程，创建一个Handler并传入子线程中的Looper
MyThread thread=new MyThread();
thread.start();
Handler handler=new Handler(thread.looper){
public void handleMessage(android.os.Message msg) {
System.out.println(msg);
};
};运行程序会出现错误，thread.looper为空，因为在主线程中创建Handler时，子线程中的Looper还没有创建，这就是多线程并发的问题。修改上面代码：
HandlerThread thread=new HandlerThread("chenxu");//主要功能就是创建Looper，参数为线程名。
thread.start();
Handler handler=new Handler(thread.getLooper()){
public void handleMessage(android.os.Message msg) {
//可执行耗时操作
System.out.println(">>>>>>>>>>>>" + Thread.currentThread());//与上面线程名一致
};
};
handler.sendEmptyMessage(1);这时的handler就相当于是子线程中的handler，即使执行耗时操作也不会出现界面卡顿的现象。
10、主线程与子线程信息交互
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Message;
public class MainActivity extends Activity {
private Handler threadHandler;
//主线程handler
Handler handler = new Handler(){
public void handleMessage(android.os.Message msg) {
Message message = new Message();
//向子线程发送消息
threadHandler.sendMessageDelayed(message, 1000);
System.out.println("main handler");
};
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
HandlerThread thread = new HandlerThread("threadHandler");//主要功能就是创建Looper，参数为线程名。
thread.start();
//子线程handler
threadHandler = new Handler(thread.getLooper()){
public void handleMessage(android.os.Message msg) {
Message message = new Message();
//向主线程发送消息
handler.sendMessageDelayed(message, 1000);
System.out.println("threadHandler handler");
};
};
handler.sendEmptyMessage(1);
}
}11、其他消息传递方法
发送消息
handler.obtainMessage(1,true).sendToTarget();
handler.obtainMessage(2,"str").sendToTarget();接收消息
Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case 1:
boolean b = (Boolean)msg.obj;
break;
case 2:
String s = (String)msg.obj;
break;
}
}
};12、Handler黄色警告
出现黄色警告是因为 Handler 在 Android 中用于消息的发送与异步处理，常常在 Activity 中作为一个匿名内部类来定义，此时 Handler 会隐式地持有一个外部类对象（通常是一个 Activity）的引用。当 Activity 已经被用户关闭时，由于 Handler 持有 Activity 的引用造成 Activity 无法被 GC 回收，这样容易造成内存泄露。
解决办法：将其定义成一个静态内部类（此时不会持有外部类对象的引用），在构造方法中传入 Activity 并对 Activity 对象增加一个弱引用，这样 Activity 被用户关闭之后，即便异步消息还未处理完毕，Activity 也能够被 GC 回收，从而避免了内存泄露。
private MyHandler mHandler = new MyHandler((Activity) context);
// 发送消息
Message message = new Message();
message.what = 1;
mHandler.sendMessage(message);
// 静态内部类
static class MyHandler extends Handler {
// 弱引用
WeakReference weakReference;
public MyHandler(Activity activity) {
weakReference = new WeakReference(activity);
}
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 1:
Toast.makeText((Context) weakReference.get(), "收到消息", Toast.LENGTH_SHORT).show();
break;
default:
// do something...
break;
}
}
}