Coroutines in Kotlin are implemented in a different way than goroutines in Go, so which one is “faster” depends on the problem that you are solving and the kind of code you are writing. In general, it is very hard to tell in advance which one is going to work better for a problem you … Read more
I would suggest to write a helper higher-order function for your retry logic. You can use the following implementation for a start: suspend fun <T> retryIO( times: Int = Int.MAX_VALUE, initialDelay: Long = 100, // 0.1 second maxDelay: Long = 1000, // 1 second factor: Double = 2.0, block: suspend () -> T): T { … Read more
Leaving my understanding here: Question 1: LaunchedEffect should be used when you want that some action must be taken when your composable is first launched/relaunched (or when the key parameter has changed). For example, when you want to request some data from your ViewModel or run some sort of animation… rememberCoroutineScope on the other hand, … Read more
Launch isn’t used anymore directly. The Kotlin documentation suggests using: fun main() { GlobalScope.launch { // launch a new coroutine in background and continue delay(1000L) println(“World!”) } println(“Hello,”) // main thread continues here immediately runBlocking { // but this expression blocks the main thread delay(2000L) // … while we delay for 2 seconds to keep … Read more
As can be seen in this post: This exception usually means that some coroutines from your tests were scheduled outside the test scope (more specifically the test dispatcher). Instead of performing this: private val networkContext: CoroutineContext = TestCoroutineDispatcher() private val sut = Foo( networkContext, someInteractor ) fun `some test`() = runBlockingTest() { // given … … Read more
Suspend function should be called only from a coroutine. That means to call a suspend function you need to use a coroutine builder, e.g. launch, async or runBlocking(recommended to use only in unit tests). For example: class Activity : AppCompatActivity(), CoroutineScope { private var job: Job = Job() override val coroutineContext: CoroutineContext get() = Dispatchers.Main … Read more
The difference is that Dispatchers.Default is limited to the number of CPU cores (with a minimum of 2) so only N (where N == cpu cores) tasks can run in parallel in this dispatcher. On the IO dispatcher there are by default 64 threads, so there could be up to 64 parallel tasks running on … Read more
Yes, in principle you are right, here more details. Scope a coroutine must run in a scope it is a way to keep track of all coroutines that run in it all (cooperative) coroutines can be cancelled via their scope scopes get uncaught exceptions they are a way to bind coroutines to an application specific … Read more
First, add org.jetbrains.kotlinx:kotlinx-coroutines-jdk8 module to your dependencies. In your Kotlin file define the following async function that corresponds to Java style of writing async APIs: fun doSomethingAsync(): CompletableFuture<List<MyClass>> = GlobalScope.future { doSomething() } Now use doSomethingAsync from Java in the same way as you are using other asynchronous APIs in the Java world.
I would take a look at this: http://www.chiark.greenend.org.uk/~sgtatham/coroutines.html, its pretty interesting and should provide a good place to start. But of course we are using Java so we can do better (or maybe worse because there are no macros :)) From my understanding with coroutines you usually have a producer and a consumer coroutine (or … Read more