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发送的消息

创建一个和线程相关的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();

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