Handler机制详解

2021-01-16 本文已影响0人 IT景隆

ITJL博客

一、什么是Handler机制

定义：

Handler是用来结合线程的消息队列来发送、处理"Message对象"和"Runnable对象"的工具。

通常的来说，就是我们在线程之间处理消息通知及任务调度的工具。

二、Handler机制原理

先捋一遍源码，画个时序图，然后等下逐一说明。

image-20210115163424214

相关类

Handler机制的实现离不开与之相关的其他三个类，Message是Handler发送的消息实体，大部分的消息都是通过Message来封装传递的；MessageQueue是用来将消息按顺序排队的队列；Looper本质就是一个循环，不停的从MessageQueue中取出消息然后处理。

执行过程

首先，如上图所示任务的开始是由创建一个Message开始的，Message创建完毕后交给Handler对象发送，sendMessage和sendMessageDelay最终都是在底层调用了sendMessageAtTime()方法，将Message对象放入MessageQueue中的。

之后，由Looper的loop()方法循环从MessageQueue中取出Message对象，调用message.getTarget ()获取到发送消息的Handler对象，然后再调用handler.dispatchMessage()方法将信息分发给对应handler执行。

最后，Handler在dispatchMessage()方法中判断是否有callback 存在，存在则执行callback的onMessageHandler()，最终交由Message.callback执行；否则则执行handler的onMessageHandler()方法。


public interface Callback {// callback接口
    public boolean handleMessage(Message msg);
}

public void handleMessage(Message msg) {

}

public void dispatchMessage(Message msg) {
    if (msg.callback != null) {
        /* 
        * callback是msg中的一个字段，是一个Runnable对象，
        * 当通过handler.post方法发送一个runnable的时候就会被封装到这个msg中
        */
        handleCallback(msg); 
        /*
        * 此方法是Handler中的一个静态方法，方法体：message.callback.run();
        * 只有这一句，可以看出是直接调用的run()方法，没有新建线程，
        * 否则也不符合这里线程通信了。
        */
    } else {
        if (mCallback != null) { // mCallback就是上面接口的对象
            if (mCallback.handleMessage(msg)) {
                /*
                * 如果返回true直接return结束方法，
                * 不再调用handler中的handleMessage方法。
                */
                return;
            }
        }
        handleMessage(msg);// handler中的消息处理方法
    }
}

三、其他的相关问题

一个线程几个 Looper，几个 Handler，Looper 如何确定是哪个 Handler？

一个线程只有一个Looper来处理MessageQueue中的消息；Handler可以有多个，用来发送及处理消息。Looper不需要确定是那个Handler发送过来的消息，因为Message有个targ字段封装了发送他的handler,系统直接通过message.getTarg().hanldMessage();就可以调用到handler的处理消息方法。

两个均不是主线的线程如何用Handler通信

在阐述这个问题时难免又要回到Handler的机制说明上；线程间的通信关键是Handler的创建，而Handler的创建本质需要一个Looper对象的存在。

Android默认在主线程中初始化了一个Looper（详见android.app.ActivityThread->Looper.prepareMainLooper()），其他线程都需要自己手动创建Looper；一个线程能够使用Handler处理消息，是必须要有Looper和MessageQueue的。

下面回到具体问题，两个都不是主线程的线程需要通过Handler通信改如何操作？根据上面的分析我们知道：

需要在处理逻辑的线程Thread1创建Looper，有了Looper之后才能创建Handler；
之后在需要发消息的线程Thread2使用Thread1的handler对象发送Message；

有了理论，之后撸一把代码：


public class MainActivity extends ComponentActivity {
    private static final String TAG = "MainActivity";
    private Looper looper2;
    private Thread1 thread1;
    private Thread thread2;
    private Handler child1Handler, child2Handler;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        initView();
    }

    private void initView() {
        setContentView(R.layout.activity_main);
        thread1 = new Thread1("ChildThread1");
        thread2 = new Thread2("ChildThread2");
        thread1.start();
        thread2.start();
    }

    private void initHandler() {
        child1Handler = new Handler(thread1.getLooper()) {
            @Override
            public void handleMessage(@NonNull Message msg) {
                String ms = (String) msg.obj;
                Log.e(TAG, "当前线程：" + Thread.currentThread().getName() + "  消息：" + ms);
                try {
                    Thread.sleep(1500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Message message = Message.obtain();
                message.obj = "你好,我是" + Thread.currentThread().getName() + "!";
                child2Handler.sendMessage(message);
            }
        };

        child2Handler = new Handler(looper2) {
            @Override
            public void handleMessage(@NonNull Message msg) {
                String ms = (String) msg.obj;
                Log.w(TAG, "当前线程：" + Thread.currentThread().getName() + "  消息：" + ms);
                try {
                    Thread.sleep(1500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Message message = Message.obtain();
                message.obj = "你好,我是" + Thread.currentThread().getName() + "!";
                child1Handler.sendMessage(message);
            }
        };
    }

    class Thread1 extends HandlerThread {
        public Thread1(String name) {
            super(name);
        }
    }

    class Thread2 extends Thread {
        public Thread2(String name) {
            super(name);
        }

        @Override
        public void run() {
            Looper.prepare();
            looper2 = Looper.myLooper();
            initHandler();
            Message message = Message.obtain();
            message.obj = "你好,我是" + Thread.currentThread().getName() + "!";
            child2Handler.sendMessage(message);
            Looper.loop();
        }
    }
}

四、Handler的内存泄露

Handler是引发内存泄露的大户，其根源还是在于Handler机制的设计结构上；

原因：

Message对象必须持有一个Handler的引用才能顺利分发任务。而如果Message在MessageQueue中不能及时被取出执行，则会导致MessageQueue长时间的持有Message对象；一般情况下我们会在Activity中以内部类的形式创建Handler；这就导致了一系列的连锁反应：

Activity 被 Handler持有，Handler被Message持有，Message被MessageQueue持有，MessageQueue中任务积压，或者是本来就是个延时任务；这就导致了内存溢出。

解决办法：

根据上述的原因我们只需要能在Handler和Activity之间断开联系，既能保证内存不再泄露；

1）内部类是在类对象创建后作为对象的一个成员存在的，而静态内部类则是在类class文件加载时就创建了，不再与外部类对象关联；因此我们可以将handler声明为静态内部类。

2）我们都知道Hander还有个内部接口Callback和与之对应的构造函数Handler(Callback callback)；


/**
 * 实现回调弱引用的Handler
 * 防止由于内部持有导致的内存泄露 
 * 传入的Callback不能使用匿名实现的变量，必须与使用这个Handle的对象的生命周期一致，
 * 否则会被立即释放掉了
 */
public class WeakRefHandler extends Handler {
    private WeakReference<Callback> mWeakReference;

    public WeakRefHandler(Callback callback) {
        mWeakReference = new WeakReference<Handler.Callback>(callback);
    }

    public WeakRefHandler(Callback callback, Looper looper) {
        super(looper);
        mWeakReference = new WeakReference<Handler.Callback>(callback);
    }

    @Override
    public void handleMessage(Message msg) {
        if (mWeakReference != null && mWeakReference.get() != null) {
            Callback callback = mWeakReference.get();
            callback.handleMessage(msg);
        }
    }
}

接下来就是使用，由于是弱引用，当该类需要被回收时，就可以直接被回收掉：


private Handler.Callback mCallback = new Handler.Callback() {
    @Override
    public boolean handleMessage(Message msg) {
        switch(msg.what){
           return true;
        }
    };
private Handler mHandler = new WeakRefHandler(mCallback);