# Coroutine Published articles for Coroutine. This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles. ## Hyperloop B: the coroutine engine behind Appwrite 2.0 DevFeed: [Hyperloop B: the coroutine engine behind Appwrite 2.0]() Original publisher: [Read original article]() Author: Luke B. Silver Published: 2026-08-31T00:00:00Z Content type: article Language: en Sources: [Appwrite Blog]() Topics: [Appwrite](), [Coroutines](), [Concurrency](), [PHP](), [Benchmark]() Tags: [architectures](), [backend](), [benchmark](), [concurrency](), [coroutine](), [coroutines](), [cpu](), [memory](), [php](), [platform](), [process](), [redis]() ### AI overview The article explains Hyperloop B, a coroutine-based engine behind Appwrite 2.0. It describes how yielding during I/O lets one process serve many concurrent requests, reporting 7x higher requests per second and 6x lower memory use on an I/O-bound benchmark. ### Source excerpt Hyperloop B is the Swoole coroutine engine behind Appwrite 2.0. Here is what it is, the concurrency problem it solves, and the 7x I/O throughput it buys. ## Native Async/Coroutine Reads in RocksDB DevFeed: [Native Async/Coroutine Reads in RocksDB]() Original publisher: [Read original article]() Author: Josh Kang Published: 2026-08-24T00:00:00Z Content type: release Language: en Sources: [RocksDB]() Topics: [rocksdb](), [Coroutines](), [C++](), [IO](), [API]() Tags: [async](), [asynchronous](), [blog](), [c-plus-plus](), [coroutine](), [io](), [native](), [rocksdb](), [thread]() ### AI overview RocksDB introduces experimental asynchronous Get and MultiGet APIs backed by native C++ coroutines. The APIs can suspend storage-bound reads, allowing a small executor to run other ready tasks and maintain more storage queue depth without one blocked application thread per read. The feature targets throughput for I/O-bound point lookups rather than reducing individual device-read latency. ### Source excerpt A point lookup that misses RocksDB's block cache can spend most of its time waiting for storage. The traditional way to keep more reads in flight is to add threads. That works, but each outstanding read parks a thread, carries a stack, and adds context-switching overhead. RocksDB now has experimental asynchronous Get and MultiGet APIs backed by native C++ coroutines. When a read reaches storage, RocksDB can suspend the request, let its read-executor worker run another ready task, and resume the request when the filesystem reports completion. A small executor can therefore maintain more storage queue depth without requiring one blocked application thread per read. These APIs are available in RocksDB 11.10.0. This is primarily a throughput feature for I/O-bound point lookups. It does not make an individual device read faster. Its benefit comes from keeping the device busy and using CPU threads for runnable work. The API surface RocksDB exposes the new read path through two public interfaces: DB::GetAsync and DB::MultiGetAsync return immediately on the native path and report completion through AsyncCallback::OnComplete. CoroDB::CoGet and CoroDB::CoMultiGet return lazy folly::coro::Task objects. CoGet produces a Status; CoMultiGet fills the same per-key values and statuses as synchronous MultiGet. The callback APIs suit applications that do not expose Folly tasks at their boundaries. The CoroDB APIs let coroutine-based callers await RocksDB directly, avoiding an application-side callback-to-Baton adapter and its extra completion handoff. Native execution requires RocksDB to be built with Folly and USE_COROUTINES=1. Neither interface requires ReadOptions::async_io. That flag continues to control the older internal async-I/O optimizations for synchronous MultiGet and iterators. The task APIs are lazy: no read begins until a task is awaited or started. Both interfaces take pointer and reference parameters, so keep the DB, column-family handles, ReadOptions, keys and their ## 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. ## How to Prevent Race Conditions in Coroutines DevFeed: [How to Prevent Race Conditions in Coroutines]() Original publisher: [Read original article]() Author: author@typealias.com (Dave Leeds) Published: 2025-11-24T00:00:00Z Content type: tutorial Language: en Sources: [Dave Leeds on Kotlin - typealias.com]() Topics: [Coroutines](), [kotlin-coroutines](), [Kotlin](), [Concurrency]() Tags: [actor](), [atomicint](), [atomics](), [concurrency](), [coroutine](), [coroutines](), [how-to](), [kotlin](), [kotlin-coroutines](), [limitedparallelism](), [mutex](), [programming](), [race-condition](), [shared-mutable-state](), [state](), [stateflow](), [structured-concurrency]() ### AI overview This tutorial explains that Kotlin coroutines and structured concurrency do not automatically protect shared mutable state from race conditions. It introduces the issue using an example that creates 100,000 random bakery orders. ### Source excerpt Thanks to structured concurrency, there are a lot of concerns that we don't have to handle manually when working with Kotlin coroutines. For example, parent coroutines automatically wait for their children to complete before completing themselves. And when a parent coroutine is cancelled, its children are automatically cancelled, too. But when it comes to shared mutable state - mutable data that multiple coroutines could update at the same time - there's nothing magical in the design of coroutines to ensure that the state is updated properly. ## Understanding Dispatchers: Main and Main.immediate DevFeed: [Understanding Dispatchers: Main and Main.immediate]() Original publisher: [Read original article]() Author: Shreyas Patil Published: 2025-04-02T12:22:06Z Content type: tutorial Language: en Sources: [Shreyas Patil's Blog]() Topics: [Coroutines](), [kotlin-coroutines](), [Kotlin](), [Android](), [Programming]() Tags: [android](), [android-app-development](), [android-apps](), [android-studio](), [coroutine](), [coroutines](), [coroutines-flow](), [kotlin](), [kotlin-beginner](), [kotlin-coroutines](), [kotlin-multiplatform](), [main-thread](), [multithreading](), [reactive-programming](), [threadpools](), [threads]() ### AI overview A deep dive into Kotlin coroutine dispatchers on Android, explaining the difference between Dispatchers.Main and Dispatchers.Main.immediate. It describes how HandlerContext dispatches work and when execution is posted to the main thread or performed synchronously on the current thread. ### Source excerpt A deep dive into Kotlin Coroutine Dispatchers. Understand the subtle but important difference between Dispatchers.Main and Dispatchers.Main.immediate in Android. ## 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 - Controlling time DevFeed: [Coroutine Testing - Controlling time]() Original publisher: [Read original article]() Author: Kaushik Gopal Published: 2024-09-04T07:00:00Z Content type: tutorial Language: en Sources: [Kaushik Gopal's Site]() Topics: [Coroutines](), [Testing](), [Code]() Tags: [coroutine](), [coroutine-testing](), [coroutines](), [test](), [testing](), [tests](), [time]() ### AI overview This tutorial explains virtual time in coroutine tests, focusing on the runCurrent, advanceTimeBy, and advanceUntilIdle APIs. It distinguishes scheduling from execution and demonstrates how StandardTestDispatcher and TestCoroutineScheduler affect test results. ### 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) My journey with coroutine testing started with this "simple" requirement -- to control virtual time in concurrent logic. From my previous post: ... If you don't use a StandardTestDispatcher explicitly, then operators like runCurrent, advanceTimeBy etc. have no meaning. I have a confession to make. I was coy saying "have no meaning". I didn't say "won't work" because in reality those apis will "work" just not in the way you'd expect. Let's dive deeper. The 3 apis # There are 3 important apis in coroutine tests to play with time: runCurrent - execute tasks scheduled at the current moment of virtual time advanceTimeBy - advance virtual time by a number of milliseconds and then execute tasks scheduled in the meantime. advanceUntilIdle - similar to advanceTimeBy but instead of advancing by a specific number of milliseconds, it keeps advancing until no more scheduled tasks are found. In the context of coroutine testing, when you think of "time", it refers simply to the order that the TestCoroutineScheduler decides to execute your scheduled coroutines. That's why the definitions above stress on words "execute" vs "scheduled". In reality, these apis belong to the class TestCoroutineScheduler (not StandardTestDispatcher as the coy comment might have indicated). Let's attempt to understand this all, with some code. StandardTestDispatcher & the 3 apis # This animation should illustrate how the different apis are designed to work.1 Your browser doesn't support HTML5 video. Download the video instead. StandardTestDispatcher is good about respecting the 3 apis. A basic test demonstrating the use of runCurrent that shouldn't be surprising: @Test fun test() = runTest(StandardTestDispatcher()) { var result = "X" launch { result = "A" delay(1.seconds) ## Coroutine Testing - Never ending tests & backgroundScope DevFeed: [Coroutine Testing - Never ending tests & backgroundScope]() Original publisher: [Read original article]() Author: Kaushik Gopal Published: 2024-08-30T07:00:45Z Content type: tutorial Language: en Sources: [Kaushik Gopal's Site]() Topics: [Coroutines](), [Unit testing](), [Kotlin](), [Testing](), [Android]() Tags: [android](), [channel](), [coroutine](), [coroutine-testing](), [coroutines](), [flow](), [job](), [kotlin](), [lifecycle](), [stateflow](), [testing](), [tests](), [unit-testing](), [viewmodel]() ### AI overview This tutorial explains why coroutine tests can time out when they collect from non-terminating Channels, SharedFlow, StateFlow, or ViewModel jobs. It presents manual Job cancellation and backgroundScope, which cancels child coroutines when the test body completes. ### 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) If you've spent some time testing Coroutines this exception should look familiar: After waiting for 1m, the test coroutine is not completing, there were active child jobs This tends to happen when you have a coroutine job in your test, that fails to complete on its own. Let's take a simple example. src on github We use a Channel here which is the proverbial event bus for Coroutines. source: kotlinlang.org Channels don't terminate on their own. So when you run a simple test checking the emission, while the items might get collected correctly per the assert statement in the test, the test itself fails like so: test on github The test here is waiting for that coroutine job to complete, which in turn requires the Channel to, but that never happens and the test times out. Where else would I run into this problem? # Channels aren't the only case you'll run into this problem. For example if you use a "hot" Flow like SharedFlow or StateFlow, they don't terminate on their own, so the onus is on you to complete or cancel their Job in tests. Android developers can frequently run into this problem too if you use ViewModels and have an internal StateFlow providing your "view level data" (what i personally like to call "view state"). You typically use the viewModelScope to launch internal coroutine jobs in a ViewModel. The OS then calls the lifecycle method onClear when the Activity or Fragment no longer needs the ViewModel where all jobs started in the viewModelScope are canceled. But when unit testing these ViewModels, you don't have access to the viewModelScope and shouldn't need it anyway. Solving this problem # There's two ways to solve this problem: 1. Manually cancel the Job ## If you have access to the Job that spawns the never-ending co ## 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 ↩︎ ## How many threads does your network client use? DevFeed: [How many threads does your network client use?]() Original publisher: [Read original article]() Published: 2024-05-13T00:00:00Z Content type: tutorial Language: en Sources: [Kt. Academy]() Topics: [Kotlin](), [kotlin-coroutines](), [Ktor](), [Spring Boot](), [client](), [Network]() Tags: [coroutine](), [coroutines](), [kotlin](), [kotlin-coroutines](), [ktor](), [network](), [spring-boot](), [threads](), [workshop-learning-programming]() ### AI overview This article examines how network clients can consume more threads than expected in Kotlin applications. It explains the thread and memory costs of blocking network requests, contrasts them with suspended Kotlin coroutines, and discusses checking client behavior in Ktor and Spring Boot applications. ### Source excerpt Many popular network clients consume way more threads than you might expect. Let's overview the problem and find a solution. ## Strategies for automatically refreshing data on Android using Kotlin Flow DevFeed: [Strategies for automatically refreshing data on Android using Kotlin Flow]() Original publisher: [Read original article]() Author: Christophe Beyls Published: 2023-10-06T17:27:03Z Content type: tutorial Language: en Sources: [Stories by Christophe Beyls on Medium]() Topics: [kotlin-flow](), [Kotlin](), [Android](), [RxJava](), [ui]() Tags: [android](), [android-app-development](), [androiddev](), [api](), [coroutine](), [flow](), [kotlin](), [kotlin-flow](), [rxjava](), [sharedflow](), [ui]() ### AI overview This tutorial explains how to periodically refresh data in Android user interfaces with Kotlin Flow. It compares sequential map() processing with concurrent, cancellation-aware mapLatest() processing and discusses lifecycle-aware refreshing and caching considerations. ### Source excerpt Making timers lifecycle-aware This is the third part of a series of articles discussing the usage of Kotlin Flow to efficiently load data in Android applications. It's a direct follow-up to part 2: "Smarter Shared Kotlin Flows", as it reuses the same concepts to cover another use case: automatic periodic refresh of the user interface. Simple periodic refresh When it's not possible to determine precisely when a data set displayed by the UI has changed, or when it changes too frequently, a common strategy is to reload the data periodically at a fixed interval while the screen is visible. One of the simplest ways to achieve this is to create a Flow from an infinite loop calling delay() between emissions: fun tickerFlow(period: Duration): Flow = flow { while (true) { emit(Unit) // Tick delay(period) } } This is equivalent to the Observable.interval() operator in RxJava with a fixed emitted value (Unit) and an initial delay of 0. Then, transform this Flow using the map() or mapLatest() operator to perform the loading action on each "tick" of the timer and return the result: tickerFlow(REFRESH_INTERVAL) .map { repository.loadSomeData() } Note the subtle difference in behavior between the two operators: With map() the entire Flow will be executed in sequence within a single coroutine, meaning delay() will only start running after the loading operation completes. As a result, each loading operation will be delayed by the amount of time it took to perform the previous loading operation, plus the fixed interval. With mapLatest() the main coroutine will collect the upstream values of tickerFlow() while a child coroutine will be created to perform the loading operation concurrently and collect the result without suspending the main coroutine. This means that delay() will start running immediately after the previous tick and each loading operation will start precisely according to schedule. This also means that the interval must be longer than the typical loading time beca ## Implementing Multiplatform Kotlin Mobile DevFeed: [Implementing Multiplatform Kotlin Mobile]() Original publisher: [Read original article]() Published: 2023-09-25T00:15:00Z Content type: tutorial Language: en Sources: [Kt. Academy]() Topics: [Kotlin Multiplatform](), [multiplatform](), [Mobile](), [Android](), [iOS](), [Development](), [business logic]() Tags: [android](), [business-logic](), [coroutine](), [dependencies](), [ios](), [kotlin](), [logic](), [mobile](), [multiplatform](), [text-to-speech](), [workshop-learning-programming]() ### AI overview This tutorial explains how Kotlin Multiplatform Mobile can share business logic between Android and iOS applications. It covers shared modules, generated platform libraries, ViewModel expect/actual classes, coroutine scopes, and interfaces for platform-specific dependencies such as text-to-speech. ### Source excerpt How in Kotlin we can implement Android and iOS projects with shared logic. ## Using annotations to improve iOS APIs on Kotlin Multiplatform DevFeed: [Using annotations to improve iOS APIs on Kotlin Multiplatform]() Original publisher: [Read original article]() Author: Marco Gomiero Published: 2023-09-19T00:00:00Z Content type: article Language: en Sources: [Posts on Marco Gomiero]() Topics: [Kotlin Multiplatform](), [interoperability](), [iOS](), [Objective-C](), [Swift](), [Kotlin](), [multiplatform]() Tags: [architecture](), [coroutine](), [interoperability](), [ios](), [kotlin](), [kotlin-multiplatform](), [mvvm](), [objective-c](), [swift]() ### AI overview This article explains how Kotlin 1.8 annotations can improve iOS APIs in a Kotlin Multiplatform project. It describes using @HiddenFromObjC and @ObjCName to expose iOS-specific implementations with clearer names while keeping shared business logic and reducing misleading duplicate class names. ### Source excerpt Kotlin 1.8 has introduced new annotations to improve the interoperability of Kotlin with Objective-C and Swift: @ObjCName: allows to customize the name that will be used in Swift or Objective-C @HiddenFromObjC: allows hiding a Kotlin declaration from Objective-C (and Swift). @ShouldRefineInSwift: it marks a Kotlin declaration as swift_private in the Objective-C API, allowing to replace it with a wrapper written in Swift. You can see the release announcement for more details about the interoperability improvements introduced with Kotlin 1.8. ## Concurrent Programming in Kotlin: Ensuring Thread Safety with Mutex DevFeed: [Concurrent Programming in Kotlin: Ensuring Thread Safety with Mutex]() Original publisher: [Read original article]() Author: Kwabena Bio Berko Published: 2023-07-18T03:33:24Z Content type: tutorial Language: en Sources: [Engineering at Premise - Medium]() Topics: [Kotlin](), [Concurrent Programming](), [Coroutines](), [Database](), [Software Engineering]() Tags: [atomic](), [code](), [component](), [concurrency](), [concurrent](), [concurrent-programming](), [coroutine](), [coroutines](), [data](), [database](), [engineering](), [function](), [implementation](), [io](), [issue](), [kotlin](), [let](), [mobile-app-development](), [mutex](), [safety](), [suspend](), [thread]() ### AI overview This Kotlin tutorial explains how Mutex provides mutual exclusion when multiple threads or coroutines call a refresh function. It shows how locking can prevent duplicate network and database operations, avoid race conditions, and preserve atomicity, while withLock can suspend callers until the current lock is released. ### Source excerpt By Kwabena Bio Berko, Android Engineer Photo by Chris Ried on Unsplash I have recently been experimenting with mutual exclusion(Mutex), a concept in software engineering to solve race conditions when accessing shared resources. Let's assume we have a component with a refresh function that can be accessed from multiple threads or coroutines: https://medium.com/media/e19aa2a9d57bc105b841d28061a199b8/href In the implementation of this component, the function retrieves data from a remote resource and inserts it into the local database. However, these operations need to be atomic. Now, imagine if 10 threads call this function simultaneously, or even a few milliseconds apart. What happens? If you guessed that we make 10 network calls and 10 database IO operations to save the items, then you would be right, as confirmed by the below test: https://medium.com/media/9b279658dbf87021068ee21a913dc80e/hrefhttps://medium.com/media/81cdc164ad807fd45df77389c00bd4cc/href But that's not what we want. It's definitely not resource-friendly. To address this issue, we can use a Mutex. As the name suggests, a Mutex provides mutual exclusion for a specific portion of your code, imposing restrictions on the access to that portion in situations where multiple threads or coroutines may attempt to access it concurrently. In essence, Mutex allows only one thread or coroutine to work within the confines of that portion of the code at any given time. By introducing a Mutex in our refresh function, we can ensure that only one thread is executing the critical sections of the code, preventing race conditions and ensuring atomicity of the operations. https://medium.com/media/9d88a802b4c73f14ceb4d5527158af5d/href In the example above, whenever the refresh function is called, we check to see if the Mutex is already locked or been used. If not, we lock it and then perform our network call and save the results in our local database. This means that whenever another thread or coroutine calls this refresh ## Eliminating coroutine races DevFeed: [Eliminating coroutine races]() Original publisher: [Read original article]() Published: 2023-06-26T00:00:00Z Content type: tutorial Language: en Sources: [Kt. Academy]() Topics: [Coroutines](), [kotlin-coroutines](), [Kotlin](), [Concurrent Programming]() Tags: [await](), [coroutine](), [coroutines](), [how-to](), [kotlin](), [kotlin-coroutines](), [workshop-learning-programming]() ### AI overview This tutorial explains how coroutine races occur when coroutines start in an unpredictable order and presents ways to coordinate them. It covers awaiting a completed coroutine, handling listener and event races in Android MVI scenarios, and using replay or completion signals for flows. ### Source excerpt How to make one coroutine await for another coroutine or flow subscription. ## OkLayoutInflater: Improving Android XML Layout Inflation with Parallel Coroutines DevFeed: [OkLayoutInflater: Improving Android XML Layout Inflation with Parallel Coroutines]() Original publisher: [Read original article]() Author: Anjal Saneen Published: 2022-10-26T01:27:02Z Content type: tutorial Language: en Sources: [OkCredit - Medium]() Topics: [Android](), [XML](), [Code](), [Parsing](), [implementation](), [IO](), [callback](), [interface]() Tags: [android](), [android-app-development](), [androiddev](), [anr](), [coroutine](), [engineering](), [file](), [io](), [main-thread](), [memory](), [mobile-app-development](), [parallelism](), [parsing](), [performance]() ### AI overview This tutorial explains how OkLayoutInflater addresses limitations in AndroidX AsyncLayoutInflater. It describes the existing implementation's sequential background inflation and presents a coroutine-based approach intended to use parallelism based on CPU cores, helping recycler view items load and scroll faster. ### Source excerpt The loading of large XML layouts is one of the major performance bottlenecks in android. Loading XML layout into memory through IO operations and parsing views through reflection can be expensive. This is especially true when the XML file is too large or when initializing the layout view takes a while. We know that when the main thread performs some time-consuming operations, it may cause the page to freeze, and even more, serious ANR may occur. Androidx AsyncLayoutInflater helps to load those layouts asynchronously. However, we found that it has some limitations. The goal of this blog post is to explain how OkLayoutInflater addresses these limitations. Source code analysis of AndroidX AsyncLayoutInflater https://android.googlesource.com/platform/frameworks/support/+/89f7eba/v4/java/android/support/v4/view/AsyncLayoutInflater.java Source code is short and easy to understand with only a few lines of code. In the inflate method, it creates an InflateRequest object and stores variables such as resid, parent, callback, etc. Then it calls enqueue to add the request to the InflateThread queue. The main purpose of InflateThread is to add requests to the blocking queue and perform BasicInflater.inflate operations in order. Regardless of inflating success or failure, the request message will be sent to the main thread for processing. The BasicInflater Inherited from LayoutInflater. In OnCreateView these prefixes are loaded on the layout. At last, mHandlerCallback implements handleMessage which executes the operation on main thread, and there is a fallback mechanism, that is when the child thread inflates fails. it will continue to inflate on the main thread, and finally, gives a callback to the main thread through the OnInflateFinishedListener interface. The limitations of AsyncLayoutInflater and how we improve it Single thread to do all the inflate work AsyncLayoutInflater has this major limitation. This was the main reason for creating a custom implementation. One of our r ## Using Coroutines and Flows with Firebase on an Android app DevFeed: [Using Coroutines and Flows with Firebase on an Android app]() Original publisher: [Read original article]() Author: Marina Coelho Published: 2022-10-26T00:00:00Z Content type: tutorial Language: en Sources: [Firebase Blog]() Topics: [Coroutines](), [Kotlin](), [Firebase](), [kotlin-coroutines](), [kotlin-flow](), [Android](), [Compose]() Tags: [android](), [compose](), [coroutine](), [coroutines](), [firebase](), [flow](), [how-to](), [jetpack-compose](), [kotlin](), [kotlin-coroutines](), [kotlin-flow]() ### AI overview A tutorial on replacing callback-based Firebase service calls with Kotlin Coroutines and Kotlin Flow in an Android application built with Jetpack Compose. It covers Firebase Authentication and Cloud Firestore examples. ### Source excerpt Learn how to use Kotlin Coroutines and Kotlin Flows with Firebase on an Android app built with Jetpack Compose. ## Combining StateFlows and transforming it into a StateFlow DevFeed: [Combining StateFlows and transforming it into a StateFlow]() Original publisher: [Read original article]() Author: Shreyas Patil Published: 2022-06-24T12:30:00Z Content type: tutorial Language: en Sources: [Shreyas Patil's Blog]() Topics: [Kotlin]() Tags: [android](), [coroutine](), [coroutines](), [kotlin](), [multithreading](), [state-management](), [stateflow]() ### AI overview A Kotlin tutorial about combining multiple StateFlows into a derived StateFlow. It explains limitations of existing Flow-combining approaches, including conversion requirements such as a scope and separately calculated initial state. ### Source excerpt Master the art of combining multiple StateFlows into a single transformed StateFlow. Explore utilities and best practices for managing complex states in Kotlin. ## Test Coroutine Scheduler DevFeed: [Test Coroutine Scheduler]() Original publisher: [Read original article]() Author: James Shvarts Published: 2022-06-24T00:55:12Z Content type: tutorial Language: en Sources: [Android Blog - Mobile Dev Notes]() Topics: [Coroutines](), [Exception](), [Library]() Tags: [coroutine](), [deprecated](), [library](), [tests](), [unit-tests]() ### AI overview A tutorial on testing Kotlin coroutines when code uses the Main dispatcher. It explains how to configure a TestCoroutineScheduler and TestDispatcher with kotlinx-coroutines-test, compares StandardTestDispatcher and UnconfinedTestDispatcher, and warns against the deprecated TestCoroutineDispatcher. ### Source excerpt Using TestCoroutineScheduler, a scheduler for coroutines used in tests, that provides the delay-skipping behavior. ## 3.17.0 Release with Computed Columns, Audit Columns, Pattern Matching, Reactive Transactions and Kotlin Coroutine Support DevFeed: [3.17.0 Release with Computed Columns, Audit Columns, Pattern Matching, Reactive Transactions and Kotlin Coroutine Support]() Original publisher: [Read original article]() Author: lukaseder Published: 2022-06-22T15:15:05Z Content type: release Language: en Sources: [jOOQ]() Topics: [releases](), [SQL](), [Kotlin](), [reactive](), [Transactions]() Tags: [audit-columns](), [client-side-computed-columns](), [computed-columns](), [coroutine](), [coroutines](), [implicit-join](), [java-17](), [jooq](), [jooq-3-17](), [jooq-development](), [kotlin](), [kotlin-coroutines](), [pattern-matching](), [postgresql](), [r2dbc](), [reactive-programming](), [reactive-transactions](), [release](), [release-notes](), [sql](), [stored](), [stored-computed-column](), [udt](), [virtual](), [virtual-computed-column]() ### AI overview The jOOQ 3.17.0 release adds client-side computed columns for read and write operations, audit columns, pattern-matching SQL transformations, and more implicit JOIN capabilities. It also sets Java 17 as the baseline for the Open Source Edition while commercial distributions continue supporting Java 8 and 11. ### Source excerpt This release contiues the work from previous releases around more sophisticated SQL transformation capabilities, including: Client side computed columns for both read and write operations Audit columns Pattern matching SQL transformations More implicit JOIN capabilities Client side computed columns A ground breaking new core feature available in all commercial distributions isthe new client side computed ... Continue reading 3.17.0 Release with Computed Columns, Audit Columns, Pattern Matching, Reactive Transactions and Kotlin Coroutine Support -> ## 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 ## Kotlin Flow Notes: Producers, Consumers, Operators, and Hot and Cold Flows DevFeed: [Kotlin Flow Notes: Producers, Consumers, Operators, and Hot and Cold Flows]() Original publisher: [Read original article]() Published: 2022-04-27T16:16:06Z Content type: tutorial Language: en Sources: [maiatoday]() Topics: [kotlin-flow](), [Kotlin](), [Coroutines](), [Large Screen](), [Streams]() Tags: [android](), [article](), [asynchronous](), [cheat-sheet](), [code](), [coroutine](), [coroutines](), [coroutines-flow](), [flow](), [kotlin](), [kotlin-coroutines](), [kotlin-flow](), [sharedflow](), [sketch-note](), [stateflow](), [streams]() ### AI overview A set of companion sketch notes about Kotlin Flow, covering suspend functions, streams of multiple values, producers and consumers, terminal and transform operators, execution contexts, hot and cold flows, and Android usage. ### Source excerpt This post is my companion sketch notes for all the resources I consumed on the topic of flows. It is not meant to replace the info that I found on the internet but rather supplement it. Nor is it complete or should it be a standalone guide. In fact you can find an excellent list of my favourite resources at the end of the article. It is a document that helps me make sense of the topic. With that disclaimer out of the way... Let's take a step back and look at the suspend function. If your coroutine knowledge is rusty, freshen that up first. What if we want to provide multiple values? A stream of values that can be observed? Enter flows. At their most basic, flows have a producer and a consumer. The interface looks like this (spoiler it's just suspend functions under the hood) The consumer gets the multiple values by using a terminal operator. If I need to change the produced values along the way before consuming them, there are transform operators. How do I switch from main to io context? What's with the hot and cold flows? How do I remember which is which? Some practical hot flows. Flows on Android References Kotlin Coroutines Flow in a nutshell Kotlin Flows ~ an Android cheat sheet Kotlin Flows in Android summary Android flow Asynchronous Flow | Kotlin Flow under the hood: how does it really work KotlinConf 2019: Asynchronous Data Streams with Kotlin Flow by Roman Elizarov Kotlin Flows in a Nutshell FlowMarbles Android StateFlow and SharedFlow If you are reading this far I will reward you with an Android portait. ## Constructing a coroutine scope DevFeed: [Constructing a coroutine scope]() Original publisher: [Read original article]() Published: 2021-10-13T00:00:00Z Content type: tutorial Language: en Sources: [Kt. Academy]() Topics: [kotlin-coroutines](), [Structured concurrency](), [Back end]() Tags: [coroutine](), [kotlin](), [logging](), [scope](), [structured-concurrency](), [workshop-learning-programming]() ### AI overview A tutorial on constructing Kotlin coroutine scopes for Android and backend code. It recommends holding a scope in a property, explains when a custom scope is needed, and discusses dispatchers, supervision, and exception handling. ### Source excerpt How we generally define coroutine scope on Android and on the backend. [Next page]()