With Kotlin comes one of its most famous features: coroutines.
Javanese is my first language. No, not the Java programming language. Javanese. So whenever I hear a foreign word like coroutines, nothing shows up in my mind. It has no meaning. This post is an attempt to dig into the word to give my brain some understanding of it.
Coroutines, Threads, Processes
First, here’s what the official documentation says about it (emphasis mine):
One can think of a coroutine as a light-weight thread. Like threads, coroutines can run in parallel, wait for each other and communicate. The biggest difference is that coroutines are very cheap, almost free: we can create thousands of them, and pay very little in terms of performance. True threads, on the other hand, are expensive to start and keep around. A thousand threads can be a serious challenge for a modern machine.“Your first coroutine with Kotlin”
I know that coroutines is a way to do asynchronous programming, and from the information above, it seems to have these three major points:
- Analogous to a light-weight thread,
- Multiple coroutines can run together at the same time, they can wait for each other, and also communicate to each other,
- Having a lot of them does not hurt performance.
I’m currently using Kotlin for programming Android apps, so the next step seems to be to figure out what exactly a thread is in this context. Here’s what the documentation says (emphasis mine):
When an application component starts and the application does not have any other components running, the Android system starts a new Linux process for the application with a single thread of execution. By default, all components of the same application run in the same process and thread (called the “main” thread). If an application component starts and there already exists a process for that application (because another component from the application exists), then the component is started within that process and uses the same thread of execution.Android Developers — Processes and Threads
So from here, it seems like within Linux there is a concept of “process”, and also “thread of execution”. According to Wikipedia:
In computing, a process is the instance of a computer program that is being executed by one or many threads. It contains the program code and its activity. Depending on the operating system (OS), a process may be made up of multiple threads of execution that execute instructions concurrentlyWikipedia — Process (computing)
This helps understanding what a “process” is. One of the definition from Merriam-Webster is: “something going on”. So in this context, a process is the idea of an app that’s currently running within Android. That’s simple enough.
Also, it just blew my mind right now that this is why a processor is called that —again, English is not my first language—it’s basically the thing that runs the apps.
Let’s have a few seconds of visual break:
Wikipedia has this to say about thread of executions:
In computer science, a thread of execution is the smallest sequence of programmed instructions that can be managed independently by a scheduler, which is typically a part of the operating system. The implementation of threads and processes differs between operating systems, but in most cases a thread is a component of a process. Multiple threads can exist within one process, executing concurrently and sharing resources such as memory, while different processes do not share these resources.Wikipedia — Thread (computing)
Thread, according to Merriam-Webster:
3 : something continuous or drawn out: such as
a : a line of reasoning or train of thought that connects the parts in a sequence (as of ideas or events)
So from the two explanations above, a process seems to be the whole existence of a running app, while a thread is the smaller element within the process.
For example in Instagram, a thread might be the start from finish when someone uploads a new picture (tap plus icon, find the image, add filter, add description, click upload, wait for it to be sent, have the image displayed). I don’t know if that’s technically accurate, but probably a good approximation.
The Wikipedia about thread also has this useful section about the difference between processes and threads:
- processes are typically independent, while threads exist as subsets of a process
- processes carry considerably more state information than threads, whereas multiple threads within a process share process state as well as memory and other resources
- processes have separate address spaces, whereas threads share their address space
- processes interact only through system-provided inter-process communication mechanisms
- context switching between threads in the same process typically occurs faster than context switching between processes
It also has this useful image:
So far we’ve learned about what a process and a thread is. And, specifically within Android, we have learned that a running app is given one process and one main thread.
So a coroutine is like a thread, and has similar behaviors, except that it’s light-weight and can perform better.
That’s a good start. Now let’s see if we can figure out what it means with multiple coroutines running in parallel, communicating and coordinating with each other.
Here is another explanation of what coroutine is:
coroutine A program component that allows structuring of a program in an unusual way. A coroutine resembles a subroutine, with one important difference. A subroutine has a subordinate position relative to the main routine: it is called and then returns. Coroutines, however, have a symmetric relation: each can call the other. Thus a coroutine is resumed at a point immediately following its call of another coroutine; it never returns, but terminates its operation by calling (resuming) another coroutine.Encyclopedia.com — coroutine
What even is a subroutine?
In computer programming, a subroutine is a sequence of program instructions that performs a specific task, packaged as a unit. This unit can then be used in programs wherever that particular task should be performed.
Subroutines may be defined within programs, or separately in libraries that can be used by many programs. In different programming languages, a subroutine may be called a procedure, a function, a routine, a method, or a subprogram. The generic term callable unit is sometimes used.Wikipedia — Subroutine
So subroutine is basically a function. I know functions! I don’t think it’s practically possible to learn programming without learning about functions anyway.
So linguistically, perhaps coroutines mean functions that can run and work together as an equal.
I’m happy with that conclusion. It’s something I can picture in my mind. It does not seem to explain technically all coroutines can do in the context of Kotlin programming, in fact it sounds a little too bland to me. However, it is concise and memorable. And that perhaps is all a good name needs to do.