HandlerThread源码理解

ゞ浴缸里的玫瑰 2024-04-01 19:10 111阅读 0赞

## 一、概述 ##

本篇文章是对Android HandlerThread源码分析并应用，谈一下自己对HandlerThread的认知理解，并通过Demo来讲解它的使用方法。

## 二、HandlerThread是什么 ##

#### 2.1 概念 ####

从字面上来讲，它是 Handler + Thread 的组合，首先它是一个Thread线程，它是用来做耗时任务用的，其次在HandlerThread中已经实现好了Looper消息循环处理，我们在应用的时候只需要通过Handler发送具体的消息给HandlerThread执行对应的任务即可。

首先明确一点：**Handler 是Android系统 同进程 不同线程间 通信用的。**

为了理解上面这句话，我们引入进程和线程的概念

**进程：**进程是对运行时程序的封装，是系统进行资源调度和分配的的基本单位，实现了操作系统的并发。

**线程：**线程是进程的子任务，是CPU调度和分派的基本单位，用于保证程序的实时性，实现进程内部的并发，每个线程都独自占用一个虚拟处理器：独自的寄存器组，指令计数器和处理器状态。

两者的区别

1. 一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。线程依赖于进程而存在。

2. 进程在执行过程中拥有独立的内存单元，而多个线程共享进程的内存。（资源分配给进程，同一进程的所有线程共享该进程的所有资源。**同一进程中的多个线程共享代码段（代码和常量），数据段（全局变量和静态变量），扩展段（堆存储）。**

比如在某个Activity界面，默认有一个UI主线程，我们称为A线程，在里面创建一个Handler， 然后在创建一个线程B，在里面做耗时任务，待任务完成，在B中通过Handler发送消息，在A中更新UI显示，这样就相当于在把线程B中的消息分发到线程A中处理，从而完成了线程间通信。

**为什么呢？因为线程A 和 线程B 可以共享数据段（Handler对象）。**

#### **2.2 特点** ####

1. HandlerThread拥有自己的消息队列，它不会干扰或阻塞UI线程。

2. 优点是不会有堵塞，减少对性能的消耗，缺点是不能同时进行多任务的处理，需要排队，处理效率较低。

3. 与线程池注重并发不同，HandlerThread是一个窜行队列，因为HandlerThread背后只有一个线程。

## 三、源码解析 ##

1. 两个构造方法

//构造方法，设置线程名称，默认线程优先级0
    public HandlerThread(String name) {
        super(name);
        mPriority = Process.THREAD_PRIORITY_DEFAULT;
    }
    
    
    //构造方法，设置线程名称和自定义线程优先级
    public HandlerThread(String name, int priority) {
        super(name);
        mPriority = priority;
    }

2. onLooperPrepared，此方法是 Looper消息循环前的准备工作，可以重写。

/**
      * Call back method that can be explicitly overridden if needed to execute some
      * setup before Looper loops.
      * Looper消息循环前的准备工作，可以重写
      */
    protected void onLooperPrepared() {
    
    }

3. run方法：当线程调用start()方法时，回调此方法

@Override
    public void run() {
    
        mTid = Process.myTid(); //线程id
    
        Looper.prepare(); // 创建Looper对象和消息队列MessageQueue
    
        synchronized (this) {  //通过同步锁机制获取当前线程的Looper对象
    
            mLooper = Looper.myLooper();
    
            notifyAll();  //通知getLooper方法looper已经创建成功，对应getLooper方法中的wait()
        }
        Process.setThreadPriority(mPriority); //设置线程优先级
    
        onLooperPrepared(); //重写此方法，作用是在消息循环之前进行一些准备工作
    
        Looper.loop(); //开启消息循环
    
        mTid = -1;
    }

4. getLpoper()方法，与run()方法中有个同步锁机制，目的是为了准确且必定要获取当前线程的Looper对象

/**
         * This method returns the Looper associated with this thread. If this thread not been started
         * or for any reason isAlive() returns false, this method will return null. If this thread
         * has been started, this method will block until the looper has been initialized.
         * @return The looper.
    
    此方法返回与此线程关联的Looper。如果此线程尚未启动或不处于活跃状态，
    则此方法将返回null。如果此线程已启动，则此方法将阻塞，直到循环器已初始化。
         */
        public Looper getLooper() {
            if (!isAlive()) {
                return null;
            }
    
            boolean wasInterrupted = false;
    
            // If the thread has been started, wait until the looper has been created.
    // 使用对象同步锁机制：如果线程已开启, 进入等待状态直到looper成功初始化.
            synchronized (this) {
                while (isAlive() && mLooper == null) {
                    try {
                        wait(); //等待Looper初始化完成，对应run方法中的notifyAll
                    } catch (InterruptedException e) {
                        wasInterrupted = true;
                    }
                }
            }
    
            /*
             * We may need to restore the thread's interrupted flag, because it may
             * have been cleared above since we eat InterruptedExceptions
             */
            if (wasInterrupted) {
                Thread.currentThread().interrupt();
            }
    
            return mLooper;
        }

为了理解上面synchronized同步锁机制，我们通过一个Demo来讲解

/**
     * author : me
     * date   : 22-11-14下午2:49
     * desc   : 线程测试类
     * version: 1.0
     */
    public class TestMain {
        public static void main(String[] args){
    
            Object object = new Object();
    
            MyThreadRunnable myThread1 = new MyThreadRunnable(object,"thread11111");
    
            Thread test1 = new Thread(myThread1);//通过public Thread(Runnable runnable)方法创建线程test1
    
            test1.start();//开始启动
    
            try {
    
                Thread.sleep(6000);
    
                System.out.println("6秒后调用notifiyAll方法唤醒线程，让线程继续执行任务");
    
                synchronized (object) {
                    object.notifyAll();
                }
    
            } catch (InterruptedException  e) {
                e.printStackTrace();
            }
        }
    }
    
    
    /**
     * author : me
     * date   : 22-11-14下午2:49
     * desc   :
     * version: 1.0
     */
    public class MyThreadRunnable implements Runnable {
    
        private Object object;
        private String threadName;
    
        public MyThreadRunnable(Object object, String threadName) {
            this.object = object;
            this.threadName = threadName;
        }
    
        @Override
        public void run() {
    
            try {
                for (int i=1; i<6; i++) {
                    if (i == 3) {
                        synchronized (this.object) {
                            System.out.println("当i==3时，线程调用wait方法 等待");
                            this.object.wait();
                        }
                    }
                    System.out.println(this.threadName + " i的值： " + i );
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

打印如下：

thread11111 i的值： 1
    thread11111 i的值： 2
    当i==3时，线程调用wait方法 等待
    6秒后调用notifiyAll方法唤醒线程，让线程继续执行任务
    thread11111 i的值： 3
    thread11111 i的值： 4
    thread11111 i的值： 5

通过此例子，再来理解上面3和4中的代码，就可以明白了。

5. getThreadHandler()方法

/**
         * @return a shared {@link Handler} associated with this thread
         * @hide
    // 返回与该线程关联的handler对象
    //注意这是一个隐藏的方法，无法直接通过 HandlerThread对象调用  getThreadHandler() 获取Handler
    */
        @NonNull
        public Handler getThreadHandler() {
            if (mHandler == null) {
                mHandler = new Handler(getLooper());
            }
            return mHandler;
        }

此方法可以忽略，是一个hide方法，无法直接调用获取Handler， 一般还是得通过

public Handler(@NonNull Looper looper)方法来 获取handler对象， 比如

Handler mThreadHandler = new Handler(myHandlerThread.getLooper()) {
                @Override
                public void handleMessage(@NonNull Message msg) {
                    //消息处理
                }
    
    }

6. quit()和quitSafely()方法

// 直接退出线程的looper消息循环，强制退出循环
        public boolean quit() {
            Looper looper = getLooper();
            if (looper != null) {
                looper.quit();
                return true;
            }
            return false;
        }
    
    
    //待消息队列中剩余消息全部处理完毕后，退出线程的looper消息循环，安全退出消息循环
        public boolean quitSafely() {
            Looper looper = getLooper();
            if (looper != null) {
                looper.quitSafely();
                return true;
            }
            return false;
        }

## 四、HandlerThread使用步骤 ##

// 步骤1：创建HandlerThread实例对象
       HandlerThread mHandlerThread = new HandlerThread("handlerThread");
    
    // 步骤2：启动线程
       mHandlerThread.start();
    
    //如果不调用start方法，会报错：
    11-15 17:30:32.347  8763  8763 E AndroidRuntime: Caused by: java.lang.NullPointerException: Attempt to read from field 'android.os.MessageQueue android.os.Looper.mQueue' on a null object reference
    11-15 17:30:32.347  8763  8763 E AndroidRuntime:    at android.os.Handler.<init>(Handler.java:257)
    11-15 17:30:32.347  8763  8763 E AndroidRuntime:    at android.os.Handler.<init>(Handler.java:162)
    
    
    //通过报错的堆栈log信息找到源码:Handler.java:257 
    public Handler(@NonNull Looper looper, @Nullable Callback callback, boolean async) {
            mLooper = looper;
            mQueue = looper.mQueue;  //这行代码报错，空对象异常
            mCallback = callback;
            mAsynchronous = async;
    }
    //looper为空对象，说明looper对象没有创建成功。 这也间接地表明 源码中通过同步锁机制必须保证要成功创建Looper对象的缘由。
    
    
    
    // 步骤3：创建工作线程Handler 并 复写handleMessage（）
    //关联HandlerThread的Looper对象、实现消息处理操作与其他线程进行通信
      Handler workHandler = new Handler( mHandlerThread.getLooper() ) {
                @Override
                //消息处理
                public boolean handleMessage(Message msg) {
                    .......
                    //当然这里可以做耗时任务，因为是处于子线程中，不会堵塞UI线程，不会引起ANR
                    return true;
                }
      });
    
    
    
    // 步骤4：使用工作线程Handler向工作线程的消息队列发送消息
      Message msg = Message.obtain();
      msg.what = 1;
      workHandler.sendMessage(msg);
    
    
    
    // 步骤5：一般在Activity的OnDestory()方法中，结束线程，即停止线程的Looper消息循环
      mHandlerThread.quit();

## 五、实例演示 ##

/**
     * author : me
     * date   : 22-11-15  下午3:46
     * desc   : 主界面
     * version: 1.0
     */
    
    public class MainActivity extends AppCompatActivity {
    
    
        private Button mButton1;
        private Button mButton2;
    
        private MyHandlerThread myHandlerThread;
    
    @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            mButton1 = findViewById(R.id.btn_one);
            mButton2 = findViewById(R.id.btn_two);
    
            //1. 创建HandlerThread实例对象
            myHandlerThread = new MyHandlerThread("handlerThread test");
    
            //2. 启动线程
            myHandlerThread.start();
    
            //3. 创建工作线程Handler, 并复写handleMessage
            Handler mThreadHandler = new Handler(myHandlerThread.getLooper()) {
    
                @Override
                public void handleMessage(@NonNull Message msg) {
                    super.handleMessage(msg);
                    if (msg.what == 1) {
                        try {
                            Log.e("test", "用线程睡眠6秒，模拟耗时任务，此任务是在子线程中处理的，所以不会引起ANR");
                            Thread.sleep(6000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        Log.e("test", "====接收主线程中发来的消息  处理消息的线程名称为：" + Thread.currentThread().getName());
                    } else if (msg.what == 2) {
                        try {
                            Log.e("test", "用线程睡眠12秒，模拟耗时任务，此任务是在子线程中处理的，所以不会引起ANR");
                            Thread.sleep(12000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        Log.e("test", "====接收自定义线程中发来的消息  处理消息的线程名称为：" + Thread.currentThread().getName());
                    }
                }
            };
    
    
            //点击此按钮： UI主线程 与 HandlerThread线程 进行通信
            mButton1.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    Message msg = Message.obtain();
                    msg.what = 1;
                    mThreadHandler.sendMessage(msg);
                    Log.e("test", "调用线程的名称：" + Thread.currentThread().getName());
                }
            });
    
            //点击此按钮： 自定义线程 与 HandlerThread线程 进行通信
            mButton2.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    Thread thread = new Thread(new Runnable() {
                        @Override
                        public void run() {
                            Message msg = Message.obtain();
                            msg.what = 2;
                            mThreadHandler.sendMessage(msg);
                            Log.e("test", "调用线程的名称：" + Thread.currentThread().getName());
                        }
                    });
                    thread.start();
                }
            });
    
    
            
    
        @Override
        protected void onDestroy() {
            super.onDestroy();
            //退出app时，子线程中的looper要退出，终止消息循环
            myHandlerThread.quitSafely();
        }
    
    }
    
    
    
    /**
     * author : me
     * date   : 22-11-14下午6:09
     * desc   :
     * version: 1.0
     */
    public class MyHandlerThread extends HandlerThread {
        public MyHandlerThread(String name) {
            super(name);
        }
    
        @Override
        protected void onLooperPrepared() {
            //如果需要执行某些Looper循环之前的设置,可以在该方法中处理
            super.onLooperPrepared();
            Log.e("test", "=====onLooperPrepared======");
        }
    
        @Override
        public boolean quitSafely() {
            Log.e("test", "=====quitSafely======");
            return super.quitSafely();
        }
    }

当进入主界面，点击button1，然后退出app，打印log如下：

11-16 17:18:49.977 23277 23384 E test    : =====onLooperPrepared======
    11-16 17:18:53.121 23277 23277 E test    : 调用线程的名称：main
    11-16 17:18:53.121 23277 23384 E test    : 用线程睡眠6秒，模拟耗时任务，此任务是在子线程中处理的，所以不会引起ANR
    11-16 17:18:59.122 23277 23384 E test    : ====接收主线程中发来的消息  处理消息的线程名称为：handlerThread test
    11-16 17:21:33.309 23277 23277 E test    : =====quitSafely======

当进入主界面，点击button2，然后退出app，打印log如下：

11-16 17:22:43.080 23277 23620 E test    : =====onLooperPrepared======
    11-16 17:22:44.758 23277 23622 E test    : 调用线程的名称：Thread-2
    11-16 17:22:44.758 23277 23620 E test    : 用线程睡眠12秒，模拟耗时任务，此任务是在子线程中处理的，所以不会引起ANR
    11-16 17:22:56.759 23277 23620 E test    : ====接收自定义线程中发来的消息  处理消息的线程名称为：handlerThread test
    11-16 17:23:06.764 23277 23277 E test    : =====quitSafely======

好了，通过此Demo可以知道Handler可以在不同进程间通信，并且了解HandlerThread的使用方法啦。

**总结**

**一. 关于Handler对象创建,取决于与哪个线程的Looper挂钩.**

**1. Handler uiHandler = new Handler() 或 new Handler(getMainLooper()) 或 new Handler(Looper.**myLooper()**); 这3个方法都是创建主线程的Handler对象.**

**2. Handler workHandler = new Handler(new HandlerThread("workthread").getLooper()); 它是创建子线程中的Handler对象.**

通过**workHandler 这个来发送消息,然后在handleMessage方法中处理任务,因为是任务在子线程中处理,所以不会引起ANR现象.**

**二. 使用注意**

**HandlerThread在线程内部创建Looper和消息队列，并且在线程启动之后开启消息循环。我们可以使用该Looper构建Handler对象从而绑定工作线程，然后通过Handler向消息队列发送消息，这样HandlerThread就可以取出消息并根据消息类型执行具体的后台任务，这里执行任务是在子线程中，它不会阻塞UI线程，所以不会引起ANR现象。**

**由于HandlerThread的run方法是一个无限循环，因此当我们不再使用HandlerThread的时候应该调用它的quit或quitSafely方法来终止线程。**