# Dispatcher Published articles for Dispatcher. This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles. ## Coroutine Essentials DevFeed: [Coroutine Essentials]() Original publisher: [Read original article]() Author: author@typealias.com (Dave Leeds) Published: 2026-08-21T00:00:00Z Content type: tutorial Language: en Sources: [Dave Leeds on Kotlin - typealias.com]() Topics: [Coroutines](), [Kotlin](), [coding](), [Software]() Tags: [async](), [cancellation](), [coding](), [concurrency](), [coroutine](), [coroutines](), [deferred](), [dispatcher](), [exception-handling](), [introduction](), [job](), [kotlin](), [launch](), [learn-to-program](), [parallelism](), [programming](), [runblocking](), [software](), [structured-concurrency](), [suspend-function](), [withcontext](), [yield]() ### AI overview This tutorial introduces essential Kotlin coroutine concepts for performing multiple tasks concurrently, such as making network calls while updating a screen. It aims to provide a foundation for day-to-day coding and more advanced coroutine concepts. ### Source excerpt When you're on hold during a phone call, you might also check your email. While brewing coffee, you might also cook breakfast. And while driving a car, you might listen to a podcast. In the same way, sometimes it's helpful for the software that we write to do more than one thing at a time. For example, it could make two or three network calls at one time--all while updating the screen to show the progress of each call. ## Don't Block Suspend Functions DevFeed: [Don't Block Suspend Functions]() Original publisher: [Read original article]() Author: Jesse Wilson Published: 2026-01-22T04:32:49Z Content type: tutorial Language: en Sources: [Public Object]() Topics: [Coroutines](), [Kotlin](), [Concurrent Programming](), [Concurrency](), [async](), [Job](), [IO]() Tags: [async](), [await](), [blocking](), [blog-post](), [concurrency](), [coroutines](), [dispatcher](), [kotlin](), [thread](), [threads]() ### AI overview This Kotlin tutorial explains why blocking calls inside suspend functions can prevent other coroutines from running. It contrasts preemptive thread concurrency with cooperative coroutine concurrency and recommends avoiding blocking functions in suspending code, using the I/O dispatcher when necessary, and avoiding runBlocking. ### Source excerpt Here's a program that launches 3 jobs. The first runs forever and the other two exchange a value. @Test fun test() = runTest { val channel = Channel() val deferredA = async { while (isActive) { delay(1_000) } } val deferredB = async { channel.send("hello") } val deferredC = async { channel.receive() } deferredB.await( ## runBlocking in practice: Where it should be used and where not DevFeed: [runBlocking in practice: Where it should be used and where not]() Original publisher: [Read original article]() Published: 2025-09-01T00:00:00Z Content type: tutorial Language: en Sources: [Kt. Academy]() Topics: [runBlocking](), [Coroutines](), [Kotlin](), [kotlin-coroutines]() Tags: [android](), [async](), [await](), [best-practices](), [blocking](), [coroutines](), [dispatcher](), [guide](), [kotlin](), [pitfalls](), [retrofit](), [runblocking](), [workshop-learning-programming]() ### AI overview A practical guide to runBlocking in Kotlin Coroutines. It explains how runBlocking converts suspending calls into blocking calls, blocks the calling thread until completion, and creates a new coroutine hierarchy. The article discusses appropriate uses, code smells, and alternatives, including an Android Retrofit interceptor example. ### Source excerpt A comprehensive guide to using runBlocking in Kotlin Coroutines, including best practices and common pitfalls. ## Dispatchers.Unconfined and why you actually want EmptyCoroutineContext DevFeed: [Dispatchers.Unconfined and why you actually want EmptyCoroutineContext]() Original publisher: [Read original article]() Author: Colin White Published: 2025-01-15T00:00:00Z Content type: tutorial Language: en Sources: [Cash App Code Blog]() Topics: [Coroutines](), [Concurrency]() Tags: [coroutine](), [coroutines](), [dispatcher](), [io](), [kotlin](), [test](), [testing]() ### AI overview The article explains why Dispatchers.Unconfined can introduce subtle threading bugs and crashes by avoiding thread dispatching. It recommends using EmptyCoroutineContext when injecting dispatchers, allowing synchronous tests while preserving correct dispatching when coroutine contexts change. ### Source excerpt Use EmptyCoroutineContext instead of Dispatchers.Unconfined. ## Coroutines and Dispatchers DevFeed: [Coroutines and Dispatchers]() Original publisher: [Read original article]() Author: Bigyan Thapa Published: 2024-10-16T06:48:00Z Content type: tutorial Language: en Sources: [Mindorks - Medium]() Topics: [Coroutines](), [android-development](), [Kotlin](), [Development]() Tags: [android](), [android-development](), [androiddev](), [best-practices](), [code-quality](), [coroutine](), [coroutines](), [dispatcher](), [extension](), [extension-function](), [io](), [kotlin](), [main-thread]() ### AI overview This tutorial explains how Android ViewModel coroutines use viewModelScope and how to select Dispatchers.IO, Dispatchers.Default, or Dispatchers.Main for I/O, CPU-intensive, and UI work. It also presents ViewModel extension functions and an overloaded function to standardize coroutine launching. ### Source excerpt In Android development, coroutines are commonly launched from ViewModel classes using viewModelScope. The typical usage looks like this: viewModelScope.launch { // ... implementation } In Android development, coroutines are commonly launched from ViewModel classes using viewModelScope. The typical usage looks like this: viewModelScope.launch { // ... implementation } By default, if a dispatcher is not specified, any coroutine launched in viewModelScope will run on the main thread. However, in most use cases, we launch these coroutines to perform background tasks, such as -- making API calls, or database operations. To ensure these tasks run in the background thread, it is essential to specify an appropriate dispatcher: I/O tasks should use Dispatchers.IO CPU-intensive tasks should use Dispatchers.Default UI updates should use Dispatchers.Main For example, to run an I/O task, we can specify the dispatcher like this: viewModelScope.launch(Dispatchers.IO) { // ...implementation }Optimizing Coroutine Launching To streamline coroutine launching, we can create extension functions on ViewModel that automatically use the specified dispatcher by default. Step 1: Create Extension Functions We can define extension functions for different dispatchers: kotlin fun ViewModel.launchIO(block: suspend CoroutineScope.() -> Unit) { viewModelScope.launch(Dispatchers.IO, block = block) } fun ViewModel.launchDefault(block: suspend CoroutineScope.() -> Unit) { viewModelScope.launch(Dispatchers.Default, block = block) } fun ViewModel.launchMain(block: suspend CoroutineScope.() -> Unit) { viewModelScope.launch(Dispatchers.Main, block = block) }Step 2: Use the Extension Functions You can now use these extension functions in your ViewModel as follows: class MyViewModel : ViewModel() { fun fetchData() { launchIO { // ... implementation } } } Benefits Consistency: These extension functions maintain consistent coroutine usage for specific tasks. Readability: The function names clearly indicate their p ## Coroutine Testing - Picking the right Dispatcher DevFeed: [Coroutine Testing - Picking the right Dispatcher]() Original publisher: [Read original article]() Author: Kaushik Gopal Published: 2024-08-25T07:00:45Z Content type: tutorial Language: en Sources: [Kaushik Gopal's Site]() Topics: [Coroutines](), [Testing](), [test](), [Code]() Tags: [coroutine-testing](), [dispatcher](), [flaky](), [scope](), [strategy](), [testing]() ### AI overview This tutorial explains how CoroutineContext, CoroutineScope, and Dispatchers affect coroutine tests. It recommends explicitly injecting a CoroutineScope and replacing it with TestScope to control dispatchers, reduce flakiness, and make tests run faster. ### Source excerpt series This is part of a series of posts on Coroutine Testing: Picking the right Dispatcher <- Never ending tests & backgroundscope Controlling time Helpful @Junit TestRule extension (coming soon) Full USF example for Android (coming soon) Most of the problems and flakiness around coroutine testing stem from running them on different Dispatchers. This is because the choice of Dispatcher can significantly impact the behavior of coroutines. This was also the most confusing1 part for me starting out -- understanding the implications of using a Scope, Context or Dispatcher. I recommend Roman's article if you want to brush up on the fundamentals. But in a nutshell: think of CoroutineContext as a collection of elements that define the coroutine. It contains a Dispatcher, Job & a CoroutineName. When you launch a coroutine, it inherits the parent's CoroutineContext (and Dispatcher), unless you specify it explicitly. A CoroutineScope on the other hand is just a way to manage and cancel (multiple) coroutines. It also defines a context and lifecycle for the coroutines launched within it (the context could be linked to yet another Dispatcher). Any coroutine when launched, runs within a CoroutineScope. Let's take an example: Notice how the current Dispatcher of the coroutine shifts from StandardTestDispatcher -> UnconfinedTestDispatcher -> Dispatcher.IO in the span of three innocuous lines based on the coroutine builder (runTest) or scope used (TestScope, turbineScope from the 3rd party library, App scope). In my initial post I pointed out this flaky test: flaky test code on github The fix for this is as simple as explicitly injecting a TestScope and making sure the same scope is used throughout. fixed test code on github Explicitly injecting the CoroutineScope and substituting it with the TestScope works really well and is my preferred strategy. This approach allows for more control over the Dispatcher used in tests . For reasons you'll see later, these tests also run instantly (72 ## Coroutine Testing DevFeed: [Coroutine Testing]() Original publisher: [Read original article]() Author: Kaushik Gopal Published: 2024-08-25T07:00:45Z Content type: tutorial Language: en Sources: [Kaushik Gopal's Site]() Topics: [Coroutines](), [Testing](), [Kotlin](), [Concurrency](), [LineageOS]() Tags: [android](), [concurrency](), [coroutine](), [coroutine-testing](), [coroutines](), [dispatcher](), [flaky](), [junit](), [kotlin](), [migration-guide](), [testing](), [time](), [tutorials]() ### AI overview A tutorial series on testing Kotlin coroutines in Android applications. It discusses changes to Kotlin testing APIs, unreliable virtual-time advancement, flaky tests, dispatchers, background scopes, and controlling time. ### Source excerpt When the #androiddevs transitioned from Rx to coroutines the topic of testing didn't get as much attention in this new world of concurrency. It didn't help that there was a seismic change in Kotlin's testing apis with 1.6.0. A whole bunch of online resources and tutorials are now defunct courtesy this change.1 My journey in the matter started because I simply couldn't understand why test apis like advanceTimeBy wouldn't work reliably for me. The name made sense... but my time wasn't being advanced in any meaningful way. Then there's the issue of flaky tests. Here's an example: flaky test code on github Run each test individually and it will pass; run them together as one test suite and test2 alone will fail. test1 passes but it takes a full 3s to run the test. If I have 300 of these in my app, are my tests going to take 15 minutes to run? I needed to understand many core concepts in order to confidently explain all the above phenomena. I'd like to share my learnings from going down the rabbit hole, in this series of posts: series This is part of a series of posts on Coroutine Testing: <- Picking the right Dispatcher Never ending tests & backgroundscope Controlling time Helpful @Junit TestRule extension (coming soon) Full USF example for Android (coming soon) If you're looking for the most current and useful resources on coroutine testing today: Untangling Coroutine Testing - Marton Braun jetbrains official docs developer.android.com docs 1.6.0 Coroutines test migration guide ↩︎ ## Kotlin Coroutines dispatchers DevFeed: [Kotlin Coroutines dispatchers]() Original publisher: [Read original article]() Published: 2024-07-01T00:00:00Z Content type: tutorial Language: en Sources: [Kt. Academy]() Topics: [kotlin-coroutines](), [Coroutines](), [Kotlin](), [Library](), [RxJava](), [Android]() Tags: [blocking](), [coroutines](), [dispatcher](), [kotlin](), [kotlin-coroutines](), [main-thread](), [rxjava](), [ui](), [workshop-learning-programming]() ### AI overview This tutorial explains Kotlin Coroutines dispatchers, which determine the thread or thread pool where coroutines start and resume. It covers the default dispatcher, limiting dispatcher parallelism, and the Main dispatcher for UI-related work, with a comparison to RxJava schedulers. ### Source excerpt Where we should use each dispatcher from the Kotlin Coroutines library. ## How to test intermediate steps in suspending functions DevFeed: [How to test intermediate steps in suspending functions]() Original publisher: [Read original article]() Published: 2022-09-30T00:00:00Z Content type: tutorial Language: en Sources: [Arkadiusz Chmura]() Topics: [Testing](), [Coroutines](), [execution]() Tags: [code-testing](), [coroutines](), [dispatcher](), [scheduler](), [testing](), [virtual]() ### AI overview This tutorial explains how to test intermediate state changes inside suspending functions. It shows how coroutine test dispatchers and virtual-time controls can verify behavior before and after a suspended network call without waiting through real delays. ### Source excerpt Testing the final result of a suspending function is easy, but what about verifying what happens inside it during the execution? ## Coroutines on Android DevFeed: [Coroutines on Android]() Original publisher: [Read original article]() Author: Stevan Milovanovic Published: 2022-05-20T12:36:23Z Content type: tutorial Language: en Sources: [Homegate Engineering Blog - Medium]() Topics: [Coroutines](), [Android](), [async](), [Concurrent Programming](), [context]() Tags: [android](), [android-app-development](), [android-apps](), [article](), [async](), [asynchronous](), [cancellation](), [coroutine](), [coroutine-testing](), [coroutines](), [dispatcher](), [kotlin-coroutines](), [lifecycle](), [programming](), [thread](), [threads]() ### AI overview This tutorial explains why Kotlin coroutines can be preferable to threads for asynchronous and background processing on Android. It introduces coroutine scopes, contexts, suspending functions, jobs, and dispatchers, and describes using coroutines for networking and background processing. ### Source excerpt Coroutines on Android In this article I'll try to explain why coroutines are useful and why would you want to use them in your project. After we go through the most important concepts of coroutines, I'll show you how I used coroutines to implement networking and background processing in the example project. First of all, you might ask yourself, why we want to use coroutines over threads? Main problem with threads is that they are resource intensive, meaning it takes a lot of resources to start a thread, stop a thread. Meanwhile, coroutines are lightweight threads, since they use thread pools. Another benefit of coroutines is that they greatly simplify asynchronous code. Callbacks and synchronisation are very easy to use. In fact, they make parallel programming look very much like sequential programming. Coroutines can be paused and resumed at any time, on a number of threads. And lastly, since coroutines are based on a few fairly easy to grasp concepts, their syntax is simple and easy to use. Here are the main concepts we need to explain about coroutines: Scope Coroutine scope, as its name says, defines a scope for new coroutines. Every coroutine builder (like launch and async) is an extension on CoroutineScope and inherits its coroutineContext to automatically propagate all its elements and cancellation. Context Coroutine context represents the context of its scope. Context is encapsulated by the scope and used for implementation of coroutine builders that are extensions on the scope. Scope provides a context in which the coroutine runs (state of the coroutine which provides variables, functionality of the coroutine etc.). Suspending functions Suspending functions are functions that can be run in a coroutine. They make callbacks seamless. They can be run in a coroutine (can be suspended) and that is why they can provide functionalities which have to be run in parallel. Job Job is a handle on that coroutine (on the piece of code which runs in the background). A laun