Basic use and internal implementation principle of handerthread

author ： Chang'an converted to his hometown

This article is mainly about HanderThread Basic use and internal implementation principle , Readers need to be right about Android The message mechanism has a certain knowledge base .

HanderThread Basic use

fun hdUse() {
    
    val handlerThread = HandlerThread("ChapterActivity", 100)
    handlerThread.start()

    val handler = Handler(handlerThread.looper) {
     msg ->
        if (msg.what == 5) {
    
            // Execute code logic 
        }
        true
    }
    handler.sendEmptyMessage(5)
}

1. First create HandlerThread, The first parameter of the constructor represents the thread name , The second parameter represents the priority of the thread , Principle analysis later
2. call HandlerThread Of start Method , Must be in getLooper Call top note before method invocation
3. establish Handler, And pass in HandlerThread Of looper
4. Then you can create it through the previous step Handler Send and process Message 了

HanderThread Collocation process

kotlinx-coroutines-android-1.4.1 Dependency provides an extension method Handler.asCoroutineDispatcher, Create a collaboration context element ——CoroutineDispatcher.

val dispatch = handler.asCoroutineDispatcher()
lifecycleScope.launch(dispatch) {
     
}

Finally, the logic in the coroutine block will be packaged into a Message, Add to handler Held looper In the message queue of , Final handler Held looper In which thread was created , In which thread will the coroutine block execute .

#HandlerContext

HanderThread Principle analysis

HandlerThread Inherited from Thread, It means that it creates a thread object . Here you can understand why HanderThread Why did the constructor of pass in the thread name and thread priority .

public class HandlerThread extends Thread

Then , Then call HandlerThread Of start Method , In other words, thread execution is enabled , Will execute the thread run Method ：

1. call Looper.prepare Method to create a file unique to the thread Looper
2. Set the priority of the current thread
3. call Looper.loop() Turn on for loop , Keep getting from the message queue Message And execute on the current thread

So , Through the top HandlerThread Created handler Sent message The final execution is HandlerThread In this created thread .

HanderThread Case on

Everybody knows ,Service Time consuming operations cannot be performed in , Or you'll be buried bomb Direct explosion ANR. So the official provided a IntentService, To realize the present Service Time consuming operations in .

public abstract class IntentService extends Service

The core code is onCreate in ： #IntentService

It looks like I'm familiar with , In essence, it is the use of HandlerThread Realized . however , Now this IntentService Has been marked as obsolete , The system recommends that we use ：