Handler面试知识小结

前言

今天我们来回顾复习下Handler,处于性能优化的考虑，Android的UI线程是线程不安全的。为了避免多个线程并发操作UI的引发UI显示错乱问题，Android指定只允许在UI线程修改更新UI组件。其他线程更新UI抛出android.view.ViewRootImpl$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.异常，当我们在子线程做完耗时操作时，需要更新UI时，我们就需要通过Handler来实现啦。

1、Handler是什么?

1、Handler通过发送和处理Message和Runnable对象来关联相对应线程的MessageQueue。

2、线程之间通信。

2、Handler使用方法

post(runnable)

sendMessage(message)

3、Handler工作原理

Handler: 负责发送消息和处理消息。

Looper: 负责管理MessageQueue，从MessageQueue中取出消息，交给消息对应的Handler处理。一个线程只有一个Looper对象。

Message: Handler接收处理的消息对象。

MessageQueue: 消息队列，负责管理Message， 先进先出。程序创建Looper对象时，会在他的构造器里创建MessageQueue对象。

总结：

1、首先Looper.prepare()在本线程中保存一个Looper实例，然后该实例中保存一个MessageQueue对象；因为Looper.prepare()在一个线程中只能调用一次，所以MessageQueue在一个线程中只会存在一个。

2、Looper.loop()会让当前线程进入一个无限循环，不断从MessageQueue的消息队列中读取消息，然后回调msg.target.dispatchMessage(msg)方法。

3、Handler的构造方法，会首先得到当前线程中保存的Looper实例，进而与Looper实例中的MessageQueue相关联。

4、Handler的sendMessage方法，会给msg的target赋值为handler自身，然后加入MessageQueue中。

5、在构造Handler实例时，我们会重写handleMessage方法，也就是msg.target.dispatchMessage(msg)最终调用的方法。

Android 异步消息处理机制 让你深入理解 Looper、Handler、Message三者关系

4、Handler引起的内存泄漏

原因：非静态内部类持有外部类的匿名引用，导致Activity无法释放。

解决：

Handler内部持有外部Activity的弱引用。

Handler改为静态内部类。

Handler.removeCallback()。

5、代码实践

第1种在UI线程创建Handler,子线程发送消息，UI线程收到消息进行处理:

由于在Activity的启动代码中在当前UI线程调用了Looper.prepare()和Looper.loop()方法，所以我们在Activity创建Handler就可以了，详情我们可以查看ActivityThread类的main 方法中，我们就会发现调用了Looper.prepareMainLooper()和Looper.loop()方法。

ActivityThread创建Looper的系统源码：

public final class ActivityThread {
public static void main(String[] args) {
// 省略部分代码
//prepareMainLooper()方法中调用了Looper.prepare(false); 创建出Looper对象
Looper.prepareMainLooper();
// 开始轮询
Looper.loop();
// 如下代码我们发现在UI线程我们不能手动调用停止Loop，不然会抛异常。
throw new RuntimeException("Main thread loop unexpectedly exited");
}
}

例子：在子线程发送消息在UI线程弹出Toast具体代码:

package com.example.ling.review.handler;

import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.widget.Toast;

import com.example.ling.review.R;

import java.lang.ref.WeakReference;

public class HandlerActivity extends AppCompatActivity {

private Handler mHandler = new MainHandler(this);

// Handler改为静态内部类，避免内存泄漏
public static class MainHandler extends Handler {

private WeakReference<HandlerActivity> mWeakReference = null;

public MainHandler(HandlerActivity activity) {
// 将Activity 包装成弱引用,避免内存泄漏
mWeakReference = new WeakReference<>(activity);
}

@Override
public void handleMessage(Message msg) {
// 接收处理消息
HandlerActivity activity = mWeakReference.get();
if (activity != null) {
Toast.makeText(activity, "我在UI线程上哦", Toast.LENGTH_SHORT).show();
}
}
}

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_handler);
initView();
}

private void initView() {
new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(2000);
// 第一种 post(runnable)用法
mHandler.post(new Runnable() {
@Override
public void run() {
Toast.makeText(getApplicationContext(), "我在UI线程上哦", Toast.LENGTH_SHORT).show();
}
});

// 第二种 sendMessage(message)用法
Thread.sleep(2000);
Message message = Message.obtain();
mHandler.sendMessage(message);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}

@Override
protected void onDestroy() {
super.onDestroy();
// activity 销毁时 Handler 移除所有回调和信息
if (mHandler != null) {
mHandler.removeCallbacksAndMessages(null);
mHandler = null;
}
}
}

第2种子线程创建Handler,在子线程发送消息，创建Handler的子线程中接收到消息进行处理：

1、子线程使用Handler需要自己创建Looper对象；
2、Looper创建完，在创建Handler对象；
3、开启Looper轮询，Handler就可以发送、处理消息啦；

例子：

public class HandlerActivity2 extends AppCompatActivity {

private ThreadHandler mHandler;

// Handler改为静态内部类，避免内存泄漏
public static class ThreadHandler extends Handler {

@Override
public void handleMessage(Message msg) {
// 接收处理消息
Log.d("TAG", "接收消息啦----- 当前线程为：" + Thread.currentThread().getName());
}
}

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_handler);
newThread1();
newThread2();
}

/**
* 创建子线程1 创建Handler
*/
private void newThread1() {
new Thread(new Runnable() {
@Override
public void run() {
Log.d("TAG", "当前线程为：" + Thread.currentThread().getName());
// 1、创建Looper
Looper.prepare();
// 2、创建Handler
mHandler = new ThreadHandler();
// 3、Looper开始轮询
Looper.loop();
}
}).start();
}

/**
* 创建子线程2 用子线程1的handler 发送消息
*/
private void newThread2() {
new Thread(new Runnable() {
@Override
public void run() {
try {
Log.d("TAG", "当前线程为：" + Thread.currentThread().getName());
Thread.sleep(2000);
Message message = Message.obtain();
mHandler.sendMessage(message);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}

@Override
protected void onDestroy() {
super.onDestroy();
// activity 销毁时 Handler 移除所有回调和信息
if (mHandler != null) {
mHandler.removeCallbacksAndMessages(null);
mHandler = null;
}
}
}

运行打印结果如下：

我们发现在Thread-2子线程创建了Handler, 在Thread-3子线程发送消息，接收到消息在Thread-2 子线程。