Summary - Concurrency patterns

Combine Mutex, Channel and rate limiter to write a work queue.

Summary - Concurrency patterns

In this group you saw concurrency patterns: mutual exclusion with Mutex, limiting with Semaphore, producer-consumer with Channel, request limits with rate limiter and fault isolation with circuit breaker.

This lesson includes a small task that combines three of them: you will produce values into a Channel and sum them with a for loop. This pattern brings together the foundation of concurrency patterns.

Exercise Summary: sum values with Channel

Open main with runBlocking. Create val ch = Channel<Int>(3); send 10, 20, 30; call close(). Initialize var sum = 0 and sum with for (v in ch) sum += v, then print println(sum).

Show example solution

import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.runBlocking

fun main() = runBlocking {
    val ch = Channel<Int>(3)
    ch.send(10)
    ch.send(20)
    ch.send(30)
    ch.close()
    var sum = 0
    for (v in ch) sum += v
    println(sum)
}

Test yourself

Which tool ensures only one coroutine enters a code block?
- Channel
- Semaphore
- Mutex
- RateLimiter
Show answer

Mutex — Mutex provides single coroutine access.
Match the concurrency tools

Mutex

Mutual exclusion
Semaphore

Bounded parallelism
Channel

Producer-consumer
CircuitBreaker

Fault isolation

Complete the withLock call

val m = Mutex()
m.____ { println("ok") }

Show answer

val m = Mutex()
m.withLock { println("ok") }

Next lesson: Hashing

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies