Android 中 Handler 的使用技巧及注意的问题
一、防止 Activity 泄露
Handler 允许我们发送延时消息，如果在延时期间用户关闭了 Activity，那么该 Activity 会泄露。这个泄露是因为 Message 会持有 Handler，而又因为 Java 的特性，内部类会持有外部类，使得 Activity 会被 Handler 持有，这样最终就导致 Activity 泄露。
解决方案：将 Handler 定义成静态的内部类，在内部持有 Activity 的弱引用，并及时移除所有消息。
public class HandlerActivity extends AppCompatActivity {
private Button bt_handler_send;
private static class MyHandler extends Handler {
//弱引用持有HandlerActivity , GC 回收时会被回收掉
private WeakReference<HandlerActivity> weakReference;
public MyHandler(HandlerActivity activity) {
this.weakReference = new WeakReference(activity);
}
@Override
public void handleMessage(Message msg) {
HandlerActivity activity = weakReference.get();
super.handleMessage(msg);
if (null != activity) {
//执行业务逻辑
Toast.makeText(activity,"handleMessage",Toast.LENGTH_SHORT).show();
}
}
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.HandlerActivity);
//创建 Handler
final MyHandler handler = new MyHandler(this);
bt_handler_send = findViewById(R.id.bt_handler_send);
bt_handler_send.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
new Thread(new Runnable() {
@Override
public void run() {
//使用 handler 发送空消息
handler.sendEmptyMessage(0);
}
}).start();
}
});
}
@Override
protected void onDestroy() {
//移除所有回调及消息
myHandler.removeCallbacksAndMessages(null);
super.onDestroy();
}
}
二、Message 获取
获取 Message 大概有如下几种方式：
Message message = myHandler.obtainMessage(); //通过 Handler 实例获取
Message message1 = Message.obtain(); //通过 Message 获取
Message message2 = new Message(); //直接创建新的 Message 实例
通过查看源码可知，Handler 的 obtainMessage() 方法也是调用了 Message 的 obtain() 方法
public final Message obtainMessage()
{
return Message.obtain(this);
}
通过查看 Message 的 obtain 方法
public static Message obtain(Handler h) {
//调用下面的方法获取 Message
Message m = obtain();
//将当前 Handler 指定给 message 的 target ，用来区分是哪个 Handler 的消息
m.target = h;
return m;
}
//从消息池中拿取 Message，如果有则返回，否则创建新的 Message
public static Message obtain() {
synchronized (sPoolSync) {
if (sPool != null) {
Message m = sPool;
sPool = m.next;
m.next = null;
m.flags = 0; // clear in-use flag
sPoolSize--;
return m;
}
}
return new Message();
}
为了节省开销，我们在使用的时候尽量复用 Message，使用前两种方式进行创建。
三、Handler 发送消息
Handler 提供了一些列的方法让我们来发送消息，如 send()系列 post()系列,post方法需要传入一个Runnalbe对象 ,我们来看看post方法源码
public final boolean post(Runnable r) {
return sendMessageDelayed(getPostMessage(r), 0);
}
不过不管我们调用什么方法，最终都会走到 MessageQueue.enqueueMessage(Message,long) 方法。以 sendEmptyMessage(int) 方法为例：
//Handler
sendEmptyMessage(int)
-> sendEmptyMessageDelayed(int,int)
-> sendMessageAtTime(Message,long)
-> enqueueMessage(MessageQueue,Message,long)
-> queue.enqueueMessage(Message, long);
从中可以发现 MessageQueue 这个消息队列，负责消息的入队，出队。
四、实例
1、子线程向主线程
首先我们在MainActivity中添加一个静态内部类，并重写其handleMessage方法。
private static class MyHandler extends Handler {
private final WeakReference<MainActivity> mTarget;
public MyHandler(MainActivity activity) {
mTarget = new WeakReference<MainActivity>(activity);
}
@Override
public void handleMessage(@NonNull Message msg) {
super.handleMessage(msg);
HandlerActivity activity = weakReference.get();
super.handleMessage(msg);
if (null != activity) {
//执行业务逻辑
if (msg.what == 0) {
Log.e("myhandler", "change textview");
MainActivity ma = mTarget.get();
ma.textView.setText("hahah");
}
Toast.makeText(activity,"handleMessage",Toast.LENGTH_SHORT).show();
}
}
}
然后创建一个类型为MyHandler的私有属性：
private Handler handler1 = new MyHandler(this);
最后在onCreate回调中创建一个线程，用于接收发送消息：
new Thread(new Runnable() {
@Override
public void run() {
handler1.sendEmptyMessage(0);
}
}).start();
总结一下：Handler的子类对象一般是在主线程中进行创建，以便在两个线程中都能访问。我们创建了Handler类的子类MyHandler，并重写了handlerMessage方法，这个方法是当使用接收处理发送的消息的。然后我们创建了一个子线程，在子线程中我们使用MyHandler的对象调用sendEmptyMessage方法发送了一个空的Message。然后我们就能在主线程中接收到这个数据。
2、主线程向子线程
首先创建一个MyHandler类。
private static class MyHandler extends Handler {
@Override
public void handleMessage(@NonNull Message msg) {
super.handleMessage(msg);
if (msg.what == 0) {
Log.e("child thread", "receive msg from main thread");
}
}
}
声明一个Handler类型的私有变量，进行默认初始化为null。
private Handler handler1;
创建子线程，使handler指向新创建的MyHandler对象。
new Thread(new Runnable() {
@Override
public void run() {
Looper.prepare();
handler1 = new MyHandler();
Looper.loop();
Log.e("child thread", "child thread end");
}
}).start();
在主线程中向子线程中发送消息
while (handler1 == null) {
handler1.sendEmptyMessage(0);
handler1.getLooper().quitSafely();
}