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