Use and principle of handlerthread

First, let's look at the inheritance interface

From the screenshot above, you can see that it is a thread class , Since it is a thread class, first see run Method

    @Override
    public void run() {
        mTid = Process.myTid();
        // Create the... Of the current thread Looper object 
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll();
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        // Start polling 
        Looper.loop();
        mTid = -1;
    }

stay run The main method is to create Looper And start looper The distribution of messages , I saw it Looper That's natural Handler

 

    /**
     * @return a shared {@link Handler} associated with this thread
     * @hide
     */
    @NonNull
    public Handler getThreadHandler() {
        if (mHandler == null) {
            mHandler = new Handler(getLooper());
        }
        return mHandler;
    }

stay HandlerThread One of them gets the current Handler Methods , This method was brought to hide Annotation we cannot call by ourselves during development and need to create handler Pass in Looper The following code

        val handlerThread = HandlerThread("handleThread")
        handlerThread.start()
        val looper = handlerThread.looper
        Handler(looper).post {
            Log.e(tag, "onCreate: ${Thread.currentThread().name}")
        }

Use this Handler The sent message will be executed in the new thread , Here's one through HandlerThread#getLooper You need to call the thread before Thread#start Let's do it first run Method or it will block the entry wait state

    public Looper getLooper() {
        if (!isAlive()) {
            return null;
        }

        boolean wasInterrupted = false;

        // If the thread has been started, wait until the looper has been created.
        synchronized (this) {
            //mLooper Will be in run Method is created 
            while (isAlive() && mLooper == null) {
                try {
                    wait();
                } 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;
    }

  Combined with the source code seen above, it is concluded that HandlerThread Namely Thread+Handler It is suitable for performing time-consuming tasks Handler