1. Parallelism vs. Concurrency · Parallel and Concurrent Programming

[THEORY]

[PREDICT]

Read the code carefully before you run it.

prediction.kt

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch(Dispatchers.Default) { println("A") }
    launch(Dispatchers.Default) { println("B") }
}

Does this program guarantee that it prints A first and then B on every run?

[TASK]

A small order service should start its own coroutine for every incoming order, reporting which thread handles it. Complete the forEach loop: start a coroutine with launch(Dispatchers.Default) for each order, printing "$order runs on ${Thread.currentThread().name}".

task.kt

import kotlinx.coroutines.* fun main() = runBlocking { val orders = listOf("Order A", "Order B", "Order C") orders.forEach { order -> // TODO: launch(Dispatchers.Default) { ... } printing order and thread name } }

Before you get a hint: what have you tried, and where exactly are you stuck?

[COMPREHENSION CHECK]

1. How does the lesson distinguish parallelism and concurrency?

Parallelism means that several computations really run at the same moment on several cores, while concurrency means that they merely make progress in overlapping time spans Parallelism means that the work is split into several threads within one process, while concurrency means that it is split into several processes on one machine Concurrency means that several computations really run at the same moment on several cores, while parallelism means that they merely make progress in overlapping time spans Both terms mean that several computations really run at the same moment on several cores, and the lesson uses them as two names for the same thing

2. A program with two coroutines runs on a machine with only one CPU core. Is that possible?

No, coroutines need at least two cores, because each running coroutine occupies one core exclusively until it has finished Yes, as long as both coroutines use the same dispatcher, because coroutines on different dispatchers each claim a core of their own Yes, and they are even parallel, because the dispatcher splits the single core into two virtual cores that compute simultaneously Yes, they are concurrent because they take turns on one core, but not parallel because they never run at the same moment

3. According to this lesson, what was the motivation for programming in parallel or concurrently at all?

Faster runtime on several cores and better responsiveness, because the application does not have to wait for one long-running operation Shorter runtime for every program, because the scheduler automatically spreads any code over all available CPU cores at runtime Simpler code, because tasks that run at the same time cannot interfere with each other and need no coordination between them Lower CPU load, because work that is split into smaller tasks needs fewer computing steps overall than one large task