Kotlin Coroutines vs Threads Efficiency Benchmark
We frequently take with no consideration the concept that Kotlin Coroutines are higher than Threads by way of efficiency. I’ve at all times been skeptical of those claims, so I made a decision to place this speculation to check by implementing a real-world benchmark and see the precise metrics. On this publish, I’ll summarize my findings, which, I suppose, would possibly shock a number of the readers.
Coroutines vs Threads Benchmark
To match the efficiency of Kotlin Coroutines and normal Threads I applied a brand new benchmark in my open-sourced TechYourChance software.
The essential concept behind this benchmark is to launch many background duties sequentially and, for every job, measure the time between a name that begins the duty and the primary instruction inside it. This length, which I name “startup length”, is mainly the latency related to transferring some work to the background.
The benchmark workout routines three totally different background work mechanisms:
- A brand new naked Thread is created and began for every job.
- A brand new Coroutine is launched for every job.
- Duties are submitted to a single thread pool for execution.
Clearly, the outcomes of this benchmark will differ between totally different units. In case you’d prefer to run the benchmark your self, then simply set up the TechYourChance app by yourself machine (see the set up directions on GitHub).
Coroutines vs Threads Outcomes
I ran the benchmark on two units:
- Samsung Galaxy S7, which is the oldest machine in my possession which is able to working the TechYourChance app.
- Samsung Galaxy S20 FE, which is my present day by day driver.
Galaxy S7 is historic and weak machine, so it ought to present an excellent approximation of the worst case efficiency. Galaxy S20 FE can be comparatively outdated and comparatively weak machine by at the moment’s normal, so its efficiency will mirror the common expertise of the underside percentiles of your customers.
These are the outcomes (please notice that the chart in TechYourChance app is zoom-able):
Outcomes Dialogue
It shouldn’t come as a shock that instantiating and beginning a brand new Thread to deal with every background job yields the worst efficiency. This method additionally demonstrates the best variance. Comparatively many information factors fall at 200% of the common startup length or extra.
The stunning result’s that utilizing Coroutines incurs ~50% startup time overhead in comparison with a typical thread pool. So, the commonly accepted concept that Coroutines are sooner than Threads seems to be incorrect.
A very powerful remark, nonetheless, is that each one these efficiency concerns are just about irrelevant within the context of Android improvement. Be aware that even on Galaxy S7, which is a dinosaur machine, instantiating and beginning a brand new Thread takes lower than 1 millisecond on common, and even the slowest startups take simply a number of milliseconds. On newer units, every thing is far sooner. This overhead is negligible for absolute majority of Android purposes on the market. Except your app begins lots of of background duties, you’ll be able to fortunately use naked Threads for background work.
Conclusion
With this comparatively easy benchmark I demonstrated that Kotlin Coroutines aren’t sooner than Threads. Not universally, not less than. Positive, I can assemble a benchmark the place Coroutines will present higher outcomes, however the state of affairs that I examined right here is definitely the most typical use case in Android purposes.
The principle takeaway from this text is to take all of the “higher efficiency” claims with a grain of salt and a dose of a wholesome skepticism. In lots of circumstances, these are simply advertising slogans. This is applicable to Kotlin Coroutines and different efficiency associated matter as properly. If there’s a common fact about efficiency, then it’s that efficiency have to be contextualized and benchmarked.
For the members of TechYourChance neighborhood I’ll document a video overview of this benchmark’s supply code. There are some fascinating concurrency-related subjects that we are able to talk about in that context. I’ll publish this overview to our discussion board in a number of days.
Thanks for studying and please depart your feedback and questions beneath.