Handler的理解和使用

2017-02-24 本文已影响510人慕涵盛华

1.Handler简介
 2.Handler的用法
 3.Android为啥要设计只能通过Handler机制去更新UI
4.Handler的原理
 5.创建一个和线程相关的Handler
6.HandlerThread
7.Android中更新UI的几种方式
 8.子线程中真的不能更新UI吗?

Handler

handler是Android给我们提供的用来更新UI的一套机制，也是一套消息处理的机制，我们可以通过它发送消息和处理消息
为什么要使用handler？
- Android在设计的时候，就封装了一套消息创建，传递和处理的机制，如果不遵守这样的机制就没有办法跟新UI，就会抛出异常信息CalledFromWrongThreadException

Handler的用法

post（Runable r）：发送一个任务，任务是运行在主线程中的

postDelayed(Runnable r, int delayMillis)：延迟发送一个任务，任务是运行在主线程中的

new Thread(){ 
    public void run() { 
       //在子线程中通过handler直接post一个任务，该任务是运行在主线程中的，所以可以更新UI
        Handler.post(new Runnable() { 
               public void run() {
                   mTextView.setText("fdfd");
               } 
        });
    };
}.start();

sendMessage(Message msg)：发送消息
handler.hasMessages(int what);检查消息中是否存在what这个消息
handler.hasMessages(int what,Object object)：检查是否存在what和object

mHandler.sendMessageDelayed(Message msg, int delayMillis)：延迟发送消息

new Thread(){ 
    public void run() { 
       Message msg = new Message();
       /** 
       * msg.what:用于区分消息，不同的消息执行不同的操作
       * msg.arg1,arg2 :用于携带简单的整形数据 
       * msg.obj:携带任何的对象 
       * msg.setData(Bundle bundle):通过bundle携带任何的数据 
       * 在handleMessage中通过getData（）去获取Bundle
       */ 
       msg.what = 1; 
       //在子线程中发送消息 
       mHandler.sendMessage(msg); 
    };
 }.start();

可以使用handler实现循环展示图片等类似的循环操作
private MyRunable runable = new MyRunable();
class MyRunable implements Runnable{
int index = 0;
@Override
public void run() {
index++;
index = index % 3;
mImageView.setImageResource(image[index]);
//每隔一秒执行当前的任务，会循环调用
//所以会一直执行下去，是在主线程中执行的
mHandler.postDelayed(runable, 1000);
}
}

拦截handler发送的消息

private Handler mHandler = new Handler(new Callback() {
        @Override
        public boolean handleMessage(Message msg) {
            Toast.makeText(getApplicationContext(), "1", 0).show();
           //设置为true，就会拦截消息，就不会执行下面的内容了
           //设置为false时，就先执行该方法中的内容再执行下面的方法
          return false;
         }
 }){
      public void handleMessage(Message msg) {
      Toast.makeText(getApplicationContext(), "2", 0).show();
  };
};

执行结果会先显示1 再显示2

取消发送消息
mHandler.removeCallbacks(runable);//取消执行之前发送的任务
handler发送消息的另一种方法
new Thread(){
public void run() {
Message msg = Message.obtain(mHandler);
msg.arg1 = 10;
//使用Message去启动消息，跟handler发送的结果一样
msg.sendToTarget();
};
}.start();

Android为啥要设计只能通过Handler机制去更新UI?

最根本的目的是解决多线程并发的问题
假设在一个Activity钟有多个线程去更新UI，而且都没有加锁机制，那会产生什么结果呢？
- 界面混乱
如果更新UI使用加锁机制会怎样呢？
- 性能下降
处于以上目的的考虑，Android为我们设计一套更新UI的机制，我们只要遵守就行，不用考虑多线程的问题，都是在主线程的消息队列中去轮询处理的

Handler的原理

Looper（轮询）
- 内部包含一个消息队列也就是MessageQueue，所有的Handler发送的消息都会存储到这个队列
- Looper.looper方法是一个死循环，不断的从MessageQueue中取消息，如果有消息就处理消息，没有就阻塞
Handler封装了消息的发送（主要把消息发送给谁）
- 内部会跟Looper关联，也就是Handler内部可以找到Looper，找到了Looper也就是找到了MessageQueue，Handler发送消息就是向消息队列MessageQueue中发送消息
- 总结：Handler负责发送消息，Looper负责接收Handler发送的消息，并直接把消息回传给Handler自己；MessageQueue就是一个消息队列，存储所有Handler发送的消息

s.png

创建一个和线程相关的Handler

如果不给Handler指定一个Looper就会出现异常
"Can't create handler inside thread that has not called Looper.prepare():没有指定Looper

class MyThread extends Thread{
    public  Handler handler;
    @Override
    public void run() {
          Looper.prepare(); //创建一个Looper对象
          handler = new Handler(){
               //此方法运行在子线程中
               @Override
               public void handleMessage(Message msg) {
                   System.out.println("当前的线程-->" + Thread.currentThread());
               }
          };
      Looper.loop(); //开始轮询
    }
}

MyThread thread = new MyThread();
thread.start(); //启动线程
//发送消息就会执行该handler的handleMessage方法（在子线程中）
thread.handler.sendEmptyMessage(1);

说明：在主线程中创建Handler时，主线程会自动创建Looper的，而自己在子线程中自定义handler机制时，需要手动创建Looper，并调用Looper的looper方法

HandlerThread

本身是一个子线程
可以实现异步操作
private HandlerThread thread;
private Handler handler;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//创建一个线程，名字为："HandlerThread"
thread = new HandlerThread("HandlerThread");
thread.start();//启动线程
//创建一个Handler，并制定此handlerde的Looper
//此处该Looper是HandlerThread线程中的，所以消息的处理实在HandlerThread线程中的（子线程）
handler = new Handler(thread.getLooper()){
//该方法运行在子线程中
@Override
public void handleMessage(Message msg) {
System.out.println("当前线程--->" + Thread.currentThread());
}
};
handler.sendEmptyMessage(1);//发送一个空的消息
}

因为handleMessage方法运行在子线程，所以可以处理耗时的操作，使用HandlerThread，可以实现异步的操作，而不用考虑什么时候创建任务，取消任务等

Demo：主线程向子线程发送消息

private HandlerThread thread; 
private Handler threadHandler; //子线程中的handler 
//主线程中的handler 
private Handler handler = new Handler(){ 
    public void handleMessage(Message msg) {
       //在主线程中向子线程发送消息 
       threadHandler.sendEmptyMessageDelayed(1, 1000);
       System.out.println("主线程向子线程发送消息"); 
     };
 }; 

@Override 
protected void onCreate(Bundle savedInstanceState) {       
     super.onCreate(savedInstanceState); 
     setContentView(R.layout.activity_main); 
     thread = new HandlerThread("异步子线程");
     thread.start(); 
     threadHandler = new Handler(thread.getLooper()){
          @Override 
           public void handleMessage(Message msg) {
                //在子线程中向主线程发送消息 
                handler.sendEmptyMessageDelayed(1, 1000);
                System.out.println("子线程向主线程发送消息"); 
         } 
    };
}

//按钮点击响应处理 
 public void click(View view){
     handler.sendEmptyMessage(1);
 }

说明：按钮点击时，handler就会发送消息，就会执行主线程中的handleMessage方法，在该方法中threadHandler就会向子线程发送消息，在子线程中handler又会发送消息，因此一直循环下去，可以在添加一个按钮，调用handler的removeCallbacks方法取消发送消息，从而结束循环

Android中更新UI的几种方式

不管是哪种方式内部都是通过handler发送消息来实现更新UI的

handler post
new Thread(){
public void run() {
//在子线程中通过handler直接post一个任务，该任务是运行在主线程中的，所以可以更新UI
mHandler.post(new Runnable() {
public void run() {
mTextView.setText("fdfd");
}
});
};
}.start();

说明post里面封装的还是sendMessage

handler sendMessage
new Thread(){
public void run() {
mHandler.sendEmptyMessage(1);
};
}.start();
/* 在主线程中运行，由哪个Handler发送的消息就由那个Handler来处理 */
private Handler mHandler = new Handler(){
public void handleMessage(Message msg) {
mTextView.setText("Update");
};
};
runOnUiThread
new Thread(){
public void run() {
//运行在主线程中
runOnUiThread(new Runnable() {
public void run() {
mTextView.setText("Update");
}
});
};
}.start();

说明：runOnUiThread内部先判断当前线程是不是主线程，如果不是就通过handler发送一个消息

view post
new Thread(){
public void run() {
mTextView.post(new Runable(){
mTextView.setText("Update");
});
};
}.start();

通过view自己post一个任务，该任务也是运行在主线程中的，内部也是通过handler发送消息来实现的

子线程中真的不能更新UI吗？

更新UI时，会判断当前的线程是不是主线程，是通过viewRootImpl判断的
viewRootImpl是在Activity的onResume()方法中初始化的
所以只要在子线程更新UI时，只要viewRootImpl没有初始化，就不会进行判断，就可以在子线程中更新UI
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mTv = (TextView) findViewById(R.id.text);
//这样是可以在子线程中更新UI的，因为此时viewRootImpl还没有初始化
new Thread(){
public void run() {
mTv.setText("子线程中跟新UI");
};
}.start();
}
////////////////////////////////////////////////////////////////////////////////////////
new Thread(){
public void run() {
try {
//这样是不能跟新的，会报异常的，因为此时已经初始化了
//android.view.ViewRootImpl$CalledFromWrongThreadException
Thread.sleep(2000);
mTv.setText("子线程中跟新UI");
} catch (InterruptedException e) {
e.printStackTrace();
}
};
}.start();

关注微信公众号获取更多相关资源

Android小先生