内容简介:There are probably many articles about Kotlin coroutines online. That’s why I would like to focus just on showing you the difference between concept over coroutines and threads – a well-known concurrency mechanism in Java. We will start from a small portio
There are probably many articles about Kotlin coroutines online. That’s why I would like to focus just on showing you the difference between concept over coroutines and threads – a well-known concurrency mechanism in Java. We will start from a small portion of theory.In general, Kotlin Coroutines are presented as a lightweight alternative to Java Threads. You would probably ask why creating them is much cheaper than creating threads. The answer is very simple – because they are not using such many threads as normal threads :wink: Of course it’s a joke, but the first important thing you should know about coroutines is that they are using thread pools in background. So, it’s not a “magical” technology, that is better than threads, but just a different concept of concurrency used in your applications.
Unlike threads, coroutines are not bound to any particular thread. A coroutine can start executing in one thread, suspend execution, and resume on a different thread. Coroutines are not managed by the operating system, but by the Kotlin Runtime. When you are sleeping a thread it is blocked for a particular period of time. So you can’t use that thread anymore until it finishes its work. In coroutines we may suspend execution, what means that the current thread is returned to a pool and may be used, for example by another coroutine. Let’s proceed to the examples.
Example
As always a source code with examples is available on GitHub. The address of repository is https://github.com/piomin/sample-kotlin-playground.git . It contains example for another article, so for test of coroutines you should take a look on pl.piomin.services.test.CoroutinesTest
class.
Implementation
Let’s start from creating a simple coroutine. Of course, there are some different ways to create coroutine, but I’m choosing the simplest one – with GlobalScope
. It means that the lifetime of each coroutine is limited only by the lifetime of the whole application or a test as in our case. We are creating coroutine 10 times and after launching it we are printing the name of currently used thread. We are not calling any suspend method here – I just want to show you how it works.
@Test fun testSimpleCoroutine() { var i: Int = 0 repeat(10) { GlobalScope.launch { println("${++i}: ${Thread.currentThread().name}") } } Thread.sleep(100) }
The order of printing messages is indeterminate. However, you may see that it was using just 3 different thread during test execution. A default thread pool used here is called DefaultDispatcher-worker
. It also add the name of coroutine to the thread name.
We may compare it to the result of this test. It does the same thing as the previous test, but uses Java thread instead of Kotlin coroutine.
@Test fun testSimpleThread() { var j: Int = 0 repeat(10) { Thread(Runnable { println("${++j}: ${Thread.currentThread().name}") }).start() } Thread.sleep(100) }
Here’s the result. As you probably expect the order of printing messages is still indeterminate (even more than earlier, but we will discuss it in the next section), but of course there were 10 running threads during the test. In comparison to the previous test it had to create 10 threads instead of 3.
It is said that Kotlin coroutines are processed sequentially. What does it mean in practice? Let’s change the default thread pool used by our coroutines to force them using just a main thread. To do that we need to override default CoroutineDispatcher
inside launch
method with Dispatchers.Unconfined
.
@Test fun testSimpleCoroutineThreadMain() { var i: Int = 0 repeat(10) { GlobalScope.launch(Dispatchers.Unconfined) { i++ println("$i: ${Thread.currentThread().name}") } } Thread.sleep(100) }
No matter how many times you will run that test, the result will be always the same. The messages are printing in order of launching new coroutines.
And finally we may proceed to the last test. We will call suspension method delay
inside our coroutine. We will also print the name of currently used thread before and after calling delay
.
@Test fun testSimpleCoroutineWithDelay() { repeat(10) { GlobalScope.launch { println("Before delay $it: ${Thread.currentThread().name}") delay(10) println("After delay $it: ${Thread.currentThread().name}") } } Thread.sleep(200) }
You can easily verify that after suspension the rest of job inside coroutine has been processed in different thread than before.
Summary
In this short article I was trying to explain you, using simple words, what exactly is Kotlin coroutine. I hope it helps you to understand the most important differences between threads and Kotlin coroutines.
以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持 码农网
猜你喜欢:本站部分资源来源于网络,本站转载出于传递更多信息之目的,版权归原作者或者来源机构所有,如转载稿涉及版权问题,请联系我们。
Dive Into Python 3
Mark Pilgrim / Apress / 2009-11-6 / USD 44.99
Mark Pilgrim's Dive Into Python 3 is a hands-on guide to Python 3 (the latest version of the Python language) and its differences from Python 2. As in the original book, Dive Into Python, each chapter......一起来看看 《Dive Into Python 3》 这本书的介绍吧!