Kotlin
Parallel &
Concurrent
Programming
@kotlin | Developed by JetBrains
Definition
According to Wikipedia:
● Parallel computing is a type of computing “in which many calculations or processes
are carried out simultaneously”.
● Concurrent computing is a form of computing in which several computations are
executed concurrently – in overlapping time periods – instead of sequentially.
● It is possible to have parallelism without concurrency, and concurrency without
parallelism.
Motivation
● Faster runtime
● Improved responsiveness
Parallelism vs concurrency
Concurrency: processes vs threads
Single-threaded process Multi-threaded process
Preemptive vs cooperative scheduling
Preemptive: OS interrupts Cooperative: task yields
tasks control
Parallel and concurrent Programming
in the JVM
● The JVM has its own scheduler
○ It is independent from the OS scheduler
○ A JVM thread != an OS thread
○ => Multithreaded JVM apps can run on a single-threaded OS
● (DOS) JVM threads are either daemons or user threads.
● The app stops when all user threads are done.
● The JVM does not wait for daemon threads to finish.
Parallel programming in the JVM
2 Java packages
● java.lang contains basic primitives: Runnable, Thread, etc
● java.util.concurrent contains synchronization primitives and concurrent data structures
Kotlin package
● kotlin.concurrent — Wrappers and extensions for Java classes
Throwback: Single abstract method
interfaces
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
Interface with a single method. We can instantiate it with a lambda.
class RunnableWrapper(val runnable: Runnable)
val myWrapperObject =
RunnableWrapper(
object : Runnable {
override fun run() {
println("I run")
}
}
)
val myWrapperLambda = RunnableWrapper { println("yo") }
Ways to create threads
You can inherit from the Thread class, which also implements Runnable.
class MyThread : Thread() {
override fun run() {
println("${currentThread()} is running")
}
}
fun main() {
val myThread = MyThread()
myThread.start()
}
run vs start
Never call Thread.run()!
run will execute on your thread, while start will create a new thread where run will be
executed.
fun main() {
val myThread1 = MyThread()
myThread1.start() // OK
val myThread2 = MyThread()
myThread2.run() // Current thread gets blocked
}
Ways to create threads
You can implement the Runnable interface and pass it
to a thread. You can pass the same Runnable to
several threads.
fun main() {
val myRunnable = Runnable { println("Sorry, gotta run!") }
val thread1 = Thread(myRunnable)
thread1.start()
val thread2 = Thread(myRunnable)
thread2.start()
}
Ways to create threads
Kotlin has an even simpler way to create threads, but under the hood the same old thread is
created and started.
import kotlin.concurrent.thread
fun main() {
val kotlinThread = thread {
println("I start instantly, but you can pass an option to start me later")
}
}
This is the preferable way to create threads.
Thread properties
A thread's properties cannot be changed after it is started.
Main properties of a thread:
● id: Long — This is the thread's identifier
● name: String
● priority: Int — This can range from 1 to 10, with a larger value indicating higher priority
● daemon: Boolean
● state: Thread.state
● isAlive: Boolean
State of a thread
state isAlive
NEW false
RUNNABLE true
BLOCKED true
WAITING true
TIMED_WAITING true
TERMINATED false
State of a thread
yield
New Runnable Running Terminated
start terminate
sched
notify wait
timeout sleep
… …
Waiting
Blocked
Ways to manipulate a thread's state
● val myThread = thread { ... } — Creates a new thread
● myThread.start() — Starts a thread
● myThread.join() — Causes the current thread to wait for another thread to finish
● sleep(...) — Puts the current thread to sleep
● yield() — Tries to step back `
● myThread.interrupt() — Tries to interrupt a thread
● myThread.isInterrupted() — Checks whether thread was interrupted
● interrupted() — Checks and clears the interruption flag
sleep, join, yield, interrupt
● The sleep and yield methods are only applicable to the current thread, which means
that you cannot suspend another thread.
● All blocking and waiting methods can throw InterruptedException
Classic worker
class ClassicWorker : Runnable {
override fun run() {
try {
while (!Thread.interrupted()) {
// do stuff
}
} catch (e: InterruptedException) {} // absolutely legal empty catch block
}
}
Parallelism and shared memory:
Examples of problematic interleaving
Parallel threads have access to the same shared memory.
This often leads to problems that cannot arise in a single-threaded environment.
class Counter { Both operations on c are single, simple statements.
private var c = 0
However, even simple statements can be translated
fun increment() { into multiple steps by the virtual machine, and those
c++ steps can be interleaved.
}
fun decrement() {
c--
}
fun value(): Int {
return c
}
}
Parallelism and shared memory:
Examples of problematic interleaving
Parallel threads have access to the same shared memory.
This often leads to problems that cannot arise in a single-threaded environment.
class Counter { Suppose both Thread#1 and Thread#2 invoke
private var c = 0 increment at the same time. If the initial value of c is
0, their interleaved actions might follow this
fun increment() { sequence:
c++
● T#1: Read value 0 from c.
}
fun decrement() { ● T#2: Read value 0 from c.
c--
} ● T#1: Increment value — result is 1.
fun value(): Int {
● T#1: Write result 1 to c.
return c
} ● T#2: Increment value — result is 1.
}
● T#2: Write result 1 to c.
Synchronization mechanisms
● Mutual exclusion, such as Lock and the synchronized keyword
● Concurrent data structures and synchronization primitives
● Atomics, which work directly with shared memory (DANGER ZONE)
Locks
class LockedCounter {
private var c = 0
private val lock = ReentrantLock()
fun increment() {
lock.withLock { c++ }
}
// same for other methods
…
}
The lock interface
● lock.lock() — Acquires the lock
● lock.tryLock() — Tries to acquire the lock
● lock.unlock() — Releases the lock
● lock.withLock { } — Executes a lambda with the lock held (has try/catch inside)
● lock.newCondition() — Creates a condition variable associated with the lock
Conditions
class PositiveLockedCounter {
private var c = 0
A condition allows a thread holding a lock
private val lock = ReentrantLock() to wait until another thread signals it
private val condition = lock.newCondition()
about a certain event. Internally, the
fun increment() {
lock.withLock {
await method releases the associated lock
c++ upon call, and acquires it back before
condition.signal()
} finally returning it again.
}
fun decrement() {
lock.withLock {
while (c == 0) {
condition.await()
}
c--
}
}
fun value(): Int {
return lock.withLock { c }
}
}
The ReentrantLock class
● ReentrantLock – Allows the lock to be acquired multiple times by the same thread
● lock.getHoldCount() – Gets the number of holds on this lock by the current thread
● lock.queuedThreads() – Gets a collection of the threads waiting on this lock
● lock.isFair() – Checks the fairness of the lock
The synchronized statement
In the JVM, every object has an intrinsic lock associated with it (aka a monitor).
class Counter {
private var c = 0
fun increment() {
synchronized(this) { c++ }
}
…
}
Synchronized method
Java Kotlin
public class SynchronizedCounter { class SynchronizedCounter {
private int c = 0; private var c = 0
public synchronized void increment() { @Synchronized
c++; fun increment() {
} c++
}
… …
} }
The ReadWriteLock class
ReadWriteLock allows multiple readers to access a resource concurrently but only lets a
single writer modify it.
● rwLock.readLock() – Returns the read lock
● rwLock.writeLock() – Returns the write lock
● rwLock.read { ... } – Executes lambda under a read lock
● rwLock.write { ... } – Executes lambda under a write lock
The ReadWriteLock Class
class PositiveLockedCounter {
private var c = 0
private val rwLock = ReadWriteReentrantLock()
fun increment() {
rwLock.write { c++ }
}
fun decrement() {
rwLock.write { c-- }
}
fun value(): Int {
return rwLock.read { c }
}
}
Concurrent blocking collections
java.util.concurrent is a Java package that implements both blocking and non-blocking
concurrent collections, such as:
● SynchronousQueue – One-element rendezvous channel
● ArrayBlockingQueue – Fixed-capacity queue
● LinkedBlockingQueue – Unbounded blocking queue
● PriorityBlockingQueue – Unbounded blocking priority queue
Concurrent non-blocking collections
java.util.concurrent is a Java package that implements both blocking and
non-blocking concurrent collections, such as:
● ConcurrentLinkedQueue – Non-blocking unbounded queue
● ConcurrentLinkedDequeue – Non-blocking unbounded dequeue
● ConcurrentHashMap – Concurrent unordered hash-map
● ConcurrentSkipListMap – Concurrent sorted hash-map
Synchronization primitives
java.util.concurrent also implements concurrent data structures and synchronization
primitives.
● Exchanger – Blocking exchange
● Phaser – Barrier synchronization
Java Memory Model: Weak behaviors
There are no guarantees when it comes to ordering! Possible outputs:
class OrderingTest { ● 0, 0
var x = 0 ● 0, 1
var y = 0
● 1, 1
fun test() {
thread { ● 1, 0
x=1
y=1
}
thread {
val a = y
val b = x
println("$a, $b")
}
}
}
Java Memory Model: Weak behaviors
There are no guarantees when it comes to progress! Possible outputs:
class ProgressTest { ● "I am free!"
var flag = false ● …
fun test() { ● …
thread { ● …
while (!flag) {} ● hang!
println("I am free!")
}
thread { flag = true }
}
}
Java Memory Model: Weak behaviors
There are no guarantees when it comes to progress! Possible outputs:
class ProgressTest { ● "I am free!"
var flag = false ● …
fun test() { ● …
thread { ● …
while (true) {} ● hang!
println("I am free!")
}
thread { flag = true }
}
}
JMM: Data-Race-Freedom Guarantee
But what does JMM guarantee?
Well-synchronized programs have simple interleaving semantics.
JMM: Data-Race-Freedom Guarantee
But what does JMM guarantee?
Well-synchronized programs have simple interleaving semantics.
Well-synchronized = Data-race-free
Simple interleaving semantics = Sequentially consistent semantics
Data-race-free programs have sequentially consistent semantics
JMM: Volatile fields
Volatile fields can be used to restore sequential consistency.
class OrderingTest { class ProgressTest {
@Volatile var x = 0 @Volatile var flag = false
@Volatile var y = 0 fun test() {
fun test() { thread {
thread { while (!flag) {}
x=1 println("I am free!")
y=1 }
} thread { flag = true }
thread { }
val a = y }
val b = x
println("$a, $b")
}
}
}
JMM: Volatile fields
Volatile variables can be used for synchronization. How do we know there is enough
synchronization?
class OrderingTest {
var x = 0
@Volatile var y = 0
fun test() {
thread {
x=1
y=1
}
thread {
val a = y
val b = x
println("$a, $b")
}
}
}
JMM: Happens-before relation
Wx0
Wy0
class OrderingTest {
po po
var x = 0
@Volatile var y = 0 V
fun test() { Wx1 Ry1
rf
thread { po po
x=1 V
rf
y=1 Wy1 Rx1
}
thread {
po
val a = y program-order
val b = x rf
println("$a, $b") reads-from
}
}
}
JMM: Happens-before relation
Wx0
Wy0
class OrderingTest {
po po
var x = 0
@Volatile var y = 0 V
fun test() { Wx1 Ry1
rf
thread { po po
x=1 V
sw
y=1 Wy1 Rx1
}
thread {
po
val a = y program-order
val b = x rf
println("$a, $b") reads-from
} sw
Synchronizes-with
}
-e.g. reads-from on Volatile field
}
JMM: Happens-before relation
Wx0
Wy0
class OrderingTest {
po po
var x = 0
@Volatile var y = 0 V
fun test() { Wx1 Ry1
hb
thread { po po
x=1 V
sw
y=1 Wy1 Rx1
}
thread {
po
val a = y program-order
val b = x rf
println("$a, $b") reads-from
} sw
Synchronizes-with
}
-e.g. reads-from on Volatile field
}
hb
happens-before
= (po ∪ sw)+
JMM: Happens-before relation
Wx0
Wy0
class OrderingTest {
po po
var x = 0
rf
@Volatile var y = 0 V
fun test() { Wx1 Ry1
hb
thread { po po
x=1 V
sw
y=1 Wy1 Rx0
}
thread {
po
val a = y program-order
val b = x rf
println("$a, $b") reads-from
} sw
Synchronizes-with
}
-e.g. reads-from on Volatile field
}
hb
happens-before
= (po ∪ sw)+
JMM: Synchronizing actions
● Read and write for volatile fields
● Lock and unlock
● Thread run and start, as well as finish and join
JMM: DRF-SC again
Two events form a data race if:
● Both are memory accesses to the same field.
● Both are plain (non-atomic) accesses.
● At least one of them is a write event.
● They are not related by happens before.
Data-race-free programs have sequentially consistent semantics
A program is data-race-free if, for every possible execution of this program, no two events
form a data race.
JMM: Atomics
But what about atomic operators on shared variables?
class Counter {
private val c = AtomicInteger()
fun increment() {
c.incrementAndGet()
}
fun decrement() {
c.decrementAndGet()
}
fun value(): Int {
return c.get()
}
}
JMM: Atomics
Atomic classes from package the java.util.concurrent.atomic package:
● AtomicInteger
● AtomicLong
● AtomicBoolean
● AtomicReference
And their array counterparts:
● AtomicIntegerArray
● AtomicLongArray
● AtomicReferenceArray
JMM: Atomics
● get() – Reads a value with volatile semantics
● set(v) – Writes a value with volatile semantics
● getAndSet(v) – Atomically exchanges a value
● compareAndSet(e, v) – Atomically compares a value of atomic variable with the
expected value, e, and if they are equal, replaces content of atomic variable with the
desired value, v; returns a boolean indicating success or failure.
● compareAndExchange(e, v) – Atomically compares a value with an expected value, e,
and if they are equal, replaces with the desired value, v; returns a read value.
● getAndIncrement(), addAndGet(d), etc – Perform Atomic arithmetic operations for ●
numeric atomics (AtomicInteger, AtomicLong).
● …
JMM: Atomics
Methods of atomic classes:
● …
● getXXX()
● setXXX(v)
● weakCompareAndSetXXX(e, v)
● compareAndExchangeXXX(e, v)
In these cases, XXX is an access mode: Acquire, Release, Opaque, Plain
You can learn more about Java Access Modes here:
https://gee.cs.oswego.edu/dl/html/j9mm.html
JMM: Atomics Problem
class Node<T>(val value: T) {
val next = AtomicReference<Node<T>>()
}
JMM: Atomic field updaters
Use AtomicXXXFieldUpdater classes to directly modify volatile fields:
class Counter {
@Volatile private var c = 0
companion object {
private val updater = AtomicIntegerFieldUpdater.newUpdater(Counter::class.java, "c")
}
fun increment() {
updater.incrementAndGet(this)
}
fun decrement() {
updater.decrementAndGet(this)
}
fun value(): Int {
return updater.get(this)
}
}
Starting from JDK9, there is also the VarHandle class, which serves a similar purpose.
Kotlin: AtomicFU
The AtomicFU library is a recommended way to use atomic operations in Kotlin:
https://github.com/Kotlin/kotlinx-atomicfu
● It provides AtomicXXX classes with API similar to
class Counter {
Java atomics.
private val c = atomic(0)
fun increment() { ● Under the hood compiler plugin replaces usage of
c += 1 atomics to AtomicXXXFieldUpdater or VarHandle.
}
fun decrement() { ● It also provides convenient extension functions, e.g.
c -= 1 c.update { it + 1 }
}
fun value(): Int {
return c.value
}
}
Thanks!
@kotlin | Developed by JetBrains
