Android Handler消息机制(五)-HandlerThread完全解析

Android 消息机制Handler完全解析(一)

Android 消息机制Handler完全解析(二)

Android Handler消息机制-消息屏障(三)

Android Handler消息机制完全解析(四)-IdleHandler和epoll机制

Android Handler消息机制(五)-HandlerThread完全解析

关于Handler的相关文章我们已经学习了四篇了，这一篇我们来学习下另一个Handler相关的知识HandlerThread，从名字来看它有Handler和Thread应该跟这两者有关，同样我们还是带着问题来学习今天的内容

• 为什么要有HandlerThread
• HandlerThread解决了什么问题

首先Handler是可以跨线程进行通讯的，大家想象一个场景:有两个Thread，ThreadA和ThreadB，如何在ThreadB中声明一个Handler对象且ThreadB中的Handler发送消息会发送到ThreadA中处理？通过前面的学习我们知道在Handler有一个传递Looper对象的构造方法

public Handler(@NonNull Looper looper) {
    this(looper, null, false);
}

因此我们可以在ThreadB中获取到ThreadA中的looper对象，然后声明Handler的时候将此looper传递给Handler对象，这样就可以达到在ThreadB中声明的Handler发送的消息会发送到ThreadA中处理。来看一段代码

Thread threadA = new Thread(new Runnable() {
    Looper looper;
    @Override
    public void run() {
        Looper.prepare();
        looper = Looper.myLooper();
        Looper.loop();
    }

    public Looper getLooper() {
        return looper;
    }
});
threadA.start();

Handler workHandler = new Handler(threadA.getLooper()) {
    @Override
     public void handleMessage(@NonNull Message msg) {
         // dosomething
     }
 };

如上所示第16行在主线程声明一个Handler的时候传递了threadA的Looper，这样通过workHandler发送的消息就能在threadA中收到，但是这样有一个问题就是上述threadA.getLooper()这个方法获取不到，因为在实例化handler的时候的Runnable是一个匿名内部类，而外部类不能直接访问匿名内部类的属性和方法，那么怎么办呢？我们可以将将Thread封装一下

public class MyHandlerThread extends Thread {
    Looper looper;

    MyHandlerThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        super.run();
        Looper.prepare();
        looper = Looper.myLooper();
        Looper.loop();
    }

    public Looper getLooper() {
        return looper;
    }
}

于是我们调用就可以像下面这样调用

MyHandlerThread threadA = new MyHandlerThread("threadTest");
threadA.start();
Handler workHandler = new Handler(threadA.getLooper());

这样封装之后似乎在线程中声明一个Handler简洁了很多，因为我们把Looper的一些操作封装在run方法里。但是这样有并发的问题，在第二行调用threadA.start之后会运行MyHandlerThread的run方法并对looper进行赋值(这个过程是在子线程中执行的)，而主线程的代码运行到第三行时会调用threadA.getLooper方法，此时有可能子线程还未对其进行赋值，也就是说此时threadA.getLooper可能为空。怎么解决这种问题呢？鉴于上述一系列问题所以谷歌给我们封装了一个HandlerThread，我们来看看它是怎么解决这个并发问题的呢？也就是说它是怎么确保执行threadA.getLooper时looper一定是有值的。要想彻底弄明白这个问题，需要对多线程并发有一定的了解，首先要理解synchronized关键字，我在这里写两段伪代码

public class Test {
    public void test1() {
        synchronized (this) {
            code1
        }
    }

    public void test2() {
        synchronized (this) {
            code2
        }
    }
}

问题来了，test1中的code1和test2中的code2是互斥访问的吗？答案是的，因为者两者持有的是同一把锁所以同一时刻只能执行一个。如果是下面这样就不会互斥

public class Test {
    public void test1() {
        synchronized (obj1) {
            code1
        }
    }

    public void test2() {
        synchronized (obj2) {
            code2
        }
    }
}

了解synchronized还不够，还需要对多线程的wait和notify有所了解，这里我直接上一个实例，这个实例就是利用多线程的wait和notify方法，来达到等待、唤醒的一个操作

public class ThreadA extends Thread {
    private Object obj;
    public ThreadA(Object obj) {
        this.obj = obj;
    }

    @Override
    public void run() {
        synchronized (obj) {
            try {
                System.out.println("wait之前的时间:" + TimeUtils.getDate(System.currentTimeMillis()));
                obj.wait();
                System.out.println("wait之后的时间:" + TimeUtils.getDate(System.currentTimeMillis()));
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

首先定义一个ThreadA它继承自Thread在构造方法中接收一个Object对象用来加锁，并重写run方法，在run方法中调用wait

public class ThreadB extends Thread {
    private Object obj;
    public ThreadB(Object obj) {
        this.obj = obj;
    }

    @Override
    public void run() {
        synchronized (obj) {
            System.out.println("notify之前的时间:" + TimeUtils.getDate(System.currentTimeMillis()));
            obj.notify();
            System.out.println("notify之后的时间:" + TimeUtils.getDate(System.currentTimeMillis()));
        }
    }
}

然后定义一个ThreadB与ThreadA类似，只不过它在run方法里调用notify方法，然后再main函数调用

Object object = new Object();
ThreadA threadA = new ThreadA(object);
threadA.start();

Thread.sleep(3000);

ThreadB threadB = new ThreadB(object);
threadB.start();

大家先想一想如何打印，打印结果

wait之前的时间:2024-10-29 17:16:09
notify之前的时间:2024-10-29 17:16:12
notify之后的时间:2024-10-29 17:16:12
wait之后的时间:2024-10-29 17:16:12

发现没有在threadA执行到wait方法后就释放了锁并进入了等待状态，后面的代码暂时不执行，等threadB拿到锁并调用notify方法并且将代码块执行完后将锁释放，此时ThreadA中的wait收到了notify的通知，继续后面的代码执行。这种场景在并发编程中也是经常用到，大家要记住这种场景的处理方式即加锁+wait+notify的方式。

回想一下我们刚才遇到的问题即如何确保threadA.getLooper()方法一定有不为null的返回值。这里是不是提供了一个思路:可以对getLooper方法加锁并进行判断如果looper为空则调用wait等待，run方法也加锁当完成了对mLooper的赋值之后notify一下，此时getLooper方法被唤醒并且looper已经完成了赋值。

说了这么多好像HandlerThread还没正式登场，上面我们讲的内容其实就是HandlerThread的主要原理，HandlerThread的源码并不多总共还不到200行，我精简一下

public class HandlerThread extends Thread {
    ...
    Looper mLooper;
    private @Nullable Handler mHandler;

    /**
     * Call back method that can be explicitly overridden if needed to execute some
     * setup before Looper loops.
     */
    protected void onLooperPrepared() {
    }

    @Override
    public void run() {
        mTid = Process.myTid();
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll();
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        Looper.loop();
        mTid = -1;
    }
    
    public Looper getLooper() {
        if (!isAlive()) {
            return null;
        }
        
        // If the thread has been started, wait until the looper has been created.
        synchronized (this) {
            while (isAlive() && mLooper == null) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }
        }
        return mLooper;
    }
    ...
}

可以看到首先HandlerThread是一个线程类它继承自Thread，并且对其进行了封装，在run方法里调用了Looper.prepare()和Looper.loop()方法，第17行和33行的锁是不是就跟我们上面讲的实例是一样，在调用getLooper方法时会判断mLooper是否为null,如果mLooper为null说明run方法里还未对mLooper赋值，此时调用wait方法进入等待状态且getLooper方法会将锁释放，run方法拿到锁并对mLooper赋值之后调用notifyAll方法此时getLooper收到这个通知，此时会再次判断mLooper是否为空，由于此时在run方法里已经对mLooper进行了赋值因此此时mLooper是不为空的，所以会执行return mLooper，这样getLooper就确保了mLooper一定有值。

关于HandlerThread的源码以及封装的过程就讲到这里，这也是关于Handler的第五篇文章了，相信这五篇文章的内容足以解决你工作和面试中的问题。

如果大家有疑问或者发现错误，欢迎在下方留言，我会在第一时间回答！！
如果觉得文章对你有帮助就帮忙点个赞吧。