当前位置：网站首页>Kotlin - Coroutine Dispatcher CoroutineDispatcher

Kotlin - Coroutine Dispatcher CoroutineDispatcher

2022-08-06 20:13:00 【lazy programmer】

  • is an abstract class, and Dispatcher is a helper class in the standard library that helps us encapsulate switching threads, and can schedule coroutines on which type of threads to execute.
  • Because the child coroutine will inherit the context of the parent coroutine, after specifying the scheduler mode on the parent coroutine, the child coroutine uses this mode by default.
  • IO and DEFAULT modes share the same thread pool, optimized threads are reused, and the number of threads is limited independently and will not starve each other.If used together to the maximum extent, the default number of active threads at the same time is 64+CPU number.
Dispatcher.MainRuns on the main thread, which is the UI thread in Android, and is used to handle some lightweight tasks of UI interaction.

Call suspend function

Call UI function

Update LiveData

Dispatcher.Main.immediateCoroutine scheduling has a cost. When we are already in the default main thread of the APP, opening a sub-coroutine (a suspend function dispatched to the main thread) is aSmall but unnecessary overhead (e.g. ViewModelScope is on Android's default main thread, so the context's scheduler uses this).In this case, specifying immediate will only be scheduled when necessary.Currently other schedulers do not support this mode.The function is wrapped withContext to be used when running on Dispatcher.Main.
Dispatcher.IO

Runs on a thread pool, optimized for blocking tasks.

Default limit of concurrently active threads ≤ 64

Database

File Read/Write

Network Processing

Dispatcher.Default

Runs on a thread pool optimized for CPU-intensive computing tasks.

2 ≤ number of threads ≤ number of CPUs

array sorting

Json parsing

processing difference judgment

Dispatcher.UnconfinedDoes not change the thread, executes on the thread that started it, and resumes its execution on the thread.Use when you don't need to care which thread the coroutine is suspended on.

Kotlin version 1.6

limitedParallelism()

public open fun limitedParallelism(parallelism: Int): CoroutineDispatcher
Default mode: When there is a task with a lot of overhead, other coroutines using the same scheduler may not be able to grab the thread execution right. At this time, it can be used to limit the coroutineThe number of threads used by the process.
IO mode: When there is a task with a lot of overhead, it may cause too many threads to be blocked and other tasks to suspend and wait, breaking the default limit of 64 threads to speed up execution.
The limit is 1 to solve the synchronization problem of multi-threaded data modification.
suspend fun main(): Unit = coroutineScope {//Use the default IO modelaunch {printTime(Dispatchers.IO) //Print: Dispatchers.IO cost: 2038/}//Add threads using limitedParallelismlaunch {val dispatcher = Dispatchers.IO.limitedParallelism(100)printTime(dispatcher) / print: [email protected] Cost: 1037}}suspend fun printTime(dispatcher: CoroutineDispatcher) {val time = measureTimeMillis {coroutineScope {repeat(100) {launch(dispatcher) {Thread.sleep(1000)}}}}println("$dispatcher spent: $time")}
原网站

版权声明
本文为[lazy programmer]所创，转载请带上原文链接，感谢
https://yzsam.com/2022/218/202208061953261383.html

边栏推荐

猜你喜欢

随机推荐