Handler的理解和使用

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();

推荐阅读更多精彩内容