HandlerThread总结

在Android系统中，执行耗时操作必须使用子线程来执行，执行完线程以后线程便会自动销毁。但是如果如果我们有很多分步的耗时操作，如果我们不断的创建新的线程执行，不断销毁线程便会消耗很多的性能，那么该怎么办呢？android给我们提供了两个方法，一个就是使用本篇文章讲的HandlerThread，另一个便是使用线程池管理线程。

一、简单使用

1.创建实例对象

//参数表示线程名称
HandlerThread handlerThread = new HandlerThread("myHandlerThread");

2.启动HandlerThread线程

handlerThread.start();

3.构建循环消息处理机制

mThreadHandler = new Handler(mHandlerThread.getLooper()) {
    @Override
    public void handleMessage(Message msg) {
        //耗时操作
    }
};

4.退出循环

如果不需要处理耗时的任务了需要让looper停下来，回收资源

mHandlerThread.getLooper().quit()
或者
mHandlerThread.getLooper().quitSafely()

二、源码解析

1.构造方法

public HandlerThread(String name) {
    super(name);
    mPriority = Process.THREAD_PRIORITY_DEFAULT;
}

public HandlerThread(String name, int priority) {
    super(name);
    mPriority = priority;
}

传入的字符串参数为线程的名字，整形参数为线程优先级，如果不指定线程优先级会被设定为默认的优先级

2.run()方法和getLooper()方法

public void run() {
    mTid = Process.myTid();
    Looper.prepare();
    //持有锁机制来获得当前线程的Looper对象
    synchronized (this) {
        mLooper = Looper.myLooper();
        //发出通知，当前线程已经创建mLooper对象成功，这里主要是通知getLooper方法中的wait
        notifyAll();
    }
    //设置线程的优先级别
    Process.setThreadPriority(mPriority);
    //这里默认是空方法的实现，我们可以重写这个方法来做一些线程开始之前的准备，方便扩展
    onLooperPrepared();
    Looper.loop();
    mTid = -1;
}

public Looper getLooper() {
    if (!isAlive()) {
        return null;
    }
    // 直到线程创建完Looper之后才能获得Looper对象，Looper未创建成功，阻塞
    synchronized (this) {
        while (isAlive() && mLooper == null) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
    }
    return mLooper;
}

使用HandlerThread的时候必须调用start()方法，因为调用start()之后，线程会交由虚拟机进行调度，虚拟机会调用run方法，完成looper的初始化，在这里还用到了锁，是为了保证线程同步，在looper实例化完成之后才获取它的对象。

3.quit()方法和quitSafe()方法

//调用这个方法退出Looper消息循环，及退出线程
public boolean quit() {
    Looper looper = getLooper();
    if (looper != null) {
        looper.quit();
        return true;
    }
    return false;
}
//调用这个方法安全地退出线程
@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
public boolean quitSafely() {
    Looper looper = getLooper();
    if (looper != null) {
        looper.quitSafely();
        return true;
    }
    return false;
}

这两个方法最后都会调用looper对象对应的方法

void quit(boolean safe) {
    if (!mQuitAllowed) {
        throw new IllegalStateException("Main thread not allowed to quit.");
    }
    synchronized (this) {
        if (mQuitting) {
            return;
        }
        mQuitting = true;
        //安全退出调用这个方法
        if (safe) {
            removeAllFutureMessagesLocked();
        } else {//不安全退出调用这个方法
            removeAllMessagesLocked();
        }
        // We can assume mPtr != 0 because mQuitting was previously false.
        nativeWake(mPtr);
    }
}

removeAllMessagesLocked()

private void removeAllMessagesLocked() {
    Message p = mMessages;
    while (p != null) {
        Message n = p.next;
        p.recycleUnchecked();
        p = n;
    }
    mMessages = null;
}

非安全退出会遍历Message链表，回收所有消息

removeAllFutureMessagesLocked()

private void removeAllFutureMessagesLocked() {
    final long now = SystemClock.uptimeMillis();
    Message p = mMessages;
    if (p != null) {
        //判断当前队列中的消息是否正在处理这个消息，没有的话，直接移除所有回调
        if (p.when > now) {
            removeAllMessagesLocked();
        } else {//正在处理的话，等待该消息处理处理完毕再退出该循环
            Message n;
            for (;;) {
                n = p.next;
                if (n == null) {
                    return;
                }
                if (n.when > now) {
                    break;
                }
                p = n;
            }
            p.next = null;
            do {
                p = n;
                n = p.next;
                p.recycleUnchecked();
            } while (n != null);
        }
    }
}

安全退出会根据Message.when这个属性，判断我们当前消息队列是否正在处理消息，没有正在处理消息的话，直接移除所有回调，正在处理的话，等待该消息处理处理完毕再退出该循环。