HandlerThread源码分析

最新推荐文章于 2024-04-09 12:41:10 发布

cwenlu

最新推荐文章于 2024-04-09 12:41:10 发布

阅读量365

点赞数

CC 4.0 BY-SA版权

分类专栏： android 文章标签：源码

本文链接：https://blog.youkuaiyun.com/u012098794/article/details/54879951

android 专栏收录该内容

10 篇文章

订阅专栏

本文详细解析了Android中HandlerThread的源码实现，包括构造方法、run方法、Looper的创建和使用过程，以及如何通过getLooper获取Looper实例。此外，还介绍了如何停止Looper接收新任务及清空消息队列的方法。

HandlerThread源码分析

public class HandlerThread extends Thread {
    //线程优先级
    int mPriority;
    //线程id
    int mTid = -1;
    Looper mLooper;

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

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

    //可以覆写，在循环之前做一些处理
    protected void onLooperPrepared() {
    }

    //创建了looper并通知getLooper。在执行getLooper之前必须先执行thread的start方法，不然getLooper将返回null，容易引发空指针
    @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;
        }
        synchronized (this) {
            while (isAlive() && mLooper == null) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }
        }
        return mLooper;
    }

    //looper停止接收新的任务并清空MessageQueue中的任务
    public boolean quit() {
        Looper looper = getLooper();
        if (looper != null) {
            looper.quit();
            return true;
        }
        return false;
    }

    //looper停止接收新的任务并清空MessageQueue中的延时任务，非延时任务将继续执行
    public boolean quitSafely() {
        Looper looper = getLooper();
        if (looper != null) {
            looper.quitSafely();
            return true;
        }
        return false;
    }


    public int getThreadId() {
        return mTid;
    }
}

Looper#quit相关源码

public void quit() {
        mQueue.quit(false);
    }


public void quitSafely() {
    mQueue.quit(true);
}

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);
        }
    }

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

    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);
            }
        }
    }