Android多线程之Handler深入浅出

Handler应用场景

为何引入Handler？

为了解决多线程并发操作UI导致的线程安全问题，Android规定只允许在UI线程中修改UI，子线程若想修改UI可通过Handler机制解决。p

如何理解Handler

Handler像是主线程的一个助手，负责处理其他子线程的消息（请求主线程更新UI），因为主线程很忙，不能即时处理，便让Handler将请求都放在一旁（消息队列里），主线程每隔一段时间就派Looper从消息队列取消息，并交给相应的Handler，Handler根据消息决定如何更新UI。

Handler处理机制

子线程调起Handler发送Message至MessageQueue。Message存储着修改UI用到的信息，MessageQueue是一个消息队列，缓存着多个Message。

主线程自动管理Looper，通过Looper定期轮询消息队列，取出Message，分发给相应的Handler。

Handler收到分发到的消息，进行处理，调用handlerMessage()方法修改UI。

在使用中，我们可以通过重写handlerMessage方法来填写业务代码，如何根据接收到的Message来修改UI就是自己程序的业务了。

 Handler、Looper、MessageQueue协同工作的示意图

这张图详细介绍了三者的工作流程。

Handler不同场景下的实例化

如果调用不带参构造器：Handler handler = new Handler()，那么这个handler会默认使用当前线程的looper。

而我们知道只有主线程可更新UI，所以如果想在子线程更新UI，可以选择在主线程无参实例化，或者选择在子线程通过Handler handler = new Handler(Looper.getMainLooper()) 实例化。

 

使用handler更新UI有多种方式：

1. 主线程实例化时重写handlerMessage处理消息，子线程通过handler.sendMessage()发送消息。

2. 主线程实例化，子线程调用handler.post方法，重写Runnable的run方法并交给handler处理。

Handler-handlerMessage-Sample

public class MainActivity extends Activity {
    private TextView mTextView;
    
    //override handlerMessage
    Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            if (msg.what == 0) {
                mTextView.setText("...");
            } else if (msg.what == 1) {
                mTextView.setText("###");
            }
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        //child thread
        new Thread(new Runnable() {
            @Override
            public void run() {
                Message msg = mHandler.obtainMessage();
                msg.what = 1;
                mHandler.sendMessage(msg);
            }
        }).start();
    }
}             

Handler-post-Sample

public class MainActivity extends Activity {
    private TextView mTextView;

    //override handlerMessage
    Handler mHandler = new Handler();

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

        //child thread
        new Thread(new Runnable() {
            @Override
            public void run() {
                mHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        mTextView.setText("###");
                    }
                });
            }
        }).start();
    }
}

关于handler.post方法再说明一下，不同于第一种方法，调用post会将一个重写的Runnable封装成Message，调起Handler机制处理Message。主线程Looper去消息队列取出Message，调起Runnable的run方法更新UI。

相比第一种重写handlerMessage方法而言，post方法更简单且不需要增加一套消息类型，消息内容的线程间的通讯逻辑。

 

关于第一种方法的Message获取与使用再简单说明一下。

Message获取的方式

1. 直接new

Message msg = new Message();

需要开辟空间，性能消耗相对大。

2. 调用obtainMessage()

Message msg = handler.obtainMessage();

从global Message pool中拿取，性能消耗相对小。

Handler传递数据方法

1. 简单int值用msg.arg

Message类含有两个arg，分别是arg1和arg2。

2. 区分消息类型用msg.what

msg.what也是int类型，可用于区分消息的类型。

3. 复杂数据用setData

将需要的数据通过key-value的形式放入Bundle，调用message.setData将bundle放入message。

 Message message = handler.obtainMessage();
 Bundle bundle = new Bundle();
 b.putSerializable("key",value); //insert key-value
 message.setData(bundle);
 message.sendToTarget(); //you can also call handler.sendMessage(message);

4. 对象用msg.obj

msg.obj可放入Object类，即各种类型，包括基本类型与对象。

Handler内存泄漏

当堆内存中的某个对象应该被释放，但是因为某些原因没有被释放，从而导致内存泄露。

通常的原因都是指这个对象被“隐式引用”导致的。

泄露原因

首先Handler是在Activity中实例化的，所以Handler持有Activity的引用。

Handler会被Message引用，而Message存储在MessageQueue中。

MessageQueue是Looper的成员对象， 所以二者也有引用关系。

Looper存储在静态的threadLocal中，静态对象是常驻内存的，也就是不会被回收。

handler并不一定会引起activity内存泄漏，只有在activity退出时，消息队列中还有这个handler发送的消息时才会引起内存泄漏。比如handler发送了一个延时消息，而该消息还没处理就退出activity，就会引起内存泄漏。

如何解决

方案：

1. Handler与Activity之间弱引用。

2. 使用静态Handler

3. 在activity的onDestory方法中执行handler.removeCallbacksAndMessages(null)

Static-Handler-WeakReference-Sample

public class MainActivity extends Activity {
    private TextView mTextView;

    private Handler mHandler = new MyHandler(this);

    private static class MyHandler extends Handler {
        private final WeakReference<MainActivity> mActivity;

        public MyHandler(MainActivity activity) {
            mActivity = new WeakReference<MainActivity>(activity);
        }

        @Override
        public void handleMessage(Message msg) {
            MainActivity activity = mActivity.get();
            if (activity == null) {
                return;
            }
            if (msg.what == 1) {
                activity.mTextView.setText("###");
            }
        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initUI();
        //child thread
        new Thread(new Runnable() {
            @Override
            public void run() {
                mHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        Message msg = mHandler.obtainMessage();
                        msg.what = 1;
                        mHandler.sendMessage(msg);
                    }
                });
            }
        }).start();
    }

    private void initUI() {
        mTextView = findViewById(R.id.tv_test);
    }
}