A short dive into the world of actors in Kotlin Mastering concurrency with coroutines 

Coroutines are cool but.. How to gurantee reading consistent states all the time? Should I use synchronized blocks? How are errors handled and propagated? Is there an equivalent to thread local with coroutines? .. or monitors? 

About us Nils Ernsting Holisticon AG is a management and IT consultancy based in Hamburg. With a holistic consulting approach, we support our customers in their development projects on a technical, tactical and strategic level. 

Actor Model Actors share nothing! 

Actor ■ Isolated lightweight processes (Kotlin coroutines) ■ Asynchronous and non-blocking ■ Can only access internal state ■ Share state by sending messages ■ Each actor has an own mailbox (channel) ■ Identified via address 

How an actor acts ■ Processes one message at a time ■ In response to a message, an actor can concurrently.. ¨ .. send a finite number of messages to other actors ¨ .. create a finite number of new actors ¨ .. designate the behaviour to be used for the next message it receives ■ No sequence assumed in which the above actions are executed 

Message passing ■ Messages are not necessarily delivered instantly ■ No sequence can be assumed on the receivers side ■ .. but it can be assumed that a message is delivered ■ Features unbound indeterminancy 

Advantages ■ Easier to avoid ¨ Race Conditions ¨ Deadlocks ¨ Starvation ¨ Live Locks ■ Variable Topology ■ Easier to consider scalability and distribution 

And what about Kotlin? 

Channel Signature in Kotlin public interface Channel : SendChannel, ReceiveChannel public interface SendChannel { public suspend fun send(element: E) public val onSend: SelectClause2> public fun offer(element: E): Boolean } public interface ReceiveChannel { public suspend fun receive(): E public val onReceive: SelectClause1 public fun poll(): E? } 

Channel Buffer Types ■ 4 different buffer types ¨ Rendevous (Unbuffered) ¨ Conflated ¨ Buffered ¨ Unlimited ■ Backpressure through limited buffer 

Channel Example val channel = Channel() launch { for (x in 1..5) channel.send(x * x) channel.close() } for (y in channel) println(y) println("Done!") 

Actors in Kotlin ■ kotlinx.coroutines provides an experimental API to build an Actor ■ Returns a SendChannel public fun CoroutineScope.actor( context: CoroutineContext = EmptyCoroutineContext, capacity: Int = 0, start: CoroutineStart = CoroutineStart.DEFAULT, onCompletion: CompletionHandler? = null, block: suspend ActorScope.() -> Unit ): SendChannel 

Actors in action Goal: Build our own crypto currency .. implementing actor model .. but without the crypto stuff ▸ Simple bank account example 

Banking Account: Messages and State sealed class BankingMessage data class Deposit(val amount: Int) : BankingMessage() data class Withdrawal(val response: SendChannel, val amount: Int) : BankingMessage() data class Balance(val response: SendChannel) : BankingMessage() data class BankingAccountState(val name: String, val balance: Int = 0) 

Banking Account: Actor @ObsoleteCoroutinesApi fun bankAccount(name: String) = GlobalScope.actor { var state = BankingAccountState(name) for (msg in channel) when (msg) { is Withdrawal -> if (msg.amount > state.balance) { msg.response.offer(false) } else { msg.response.offer(true) state = state.copy(balance = state.balance - msg.amount) } .. } } 

Banking Account: Access Methods typealias BankAccount = SendChannel suspend fun BankAccount.deposit(amount:Int) = this.send(Deposit(amount)) suspend fun BankAccount.withdrawal(amount:Int) = Channel() .also { this.send(Withdrawal(it, amount)) } suspend fun BankAccount.balance() = Channel() .also { this.send(Balance(it)) } 

Banking Account: Access Methods typealias BankAccount = SendChannel suspend fun BankAccount.deposit(amount:Int) = this.send(Deposit(amount)) suspend fun BankAccount.withdrawal(amount:Int) = Channel(capacity=1) .also { this.send(Withdrawal(it, amount)) } suspend fun BankAccount.balance() = Channel(capacity=1) .also { this.send(Balance(it)) } 

Banking Account: Usage val ron = bankAccount("Ron") val amelie = bankAccount("Amelie") ron.deposit(50) amelie.deposit(100) val success = ron.withdrawal(20).receive() println(ron.balance().receive()) 

How to transfer money between two actors? 

Banking Account: Money Transfer @ObsoleteCoroutinesApi fun transfer(sender: BankAccount, receiver: BankAccount, amount: Int) = Channel().also { GlobalScope.actor { val result = sender.withdrawal(amount).receive() if (result) { receiver.deposit(amount) } it.send(result) } } val success = transfer(sender = ron, receiver = amelie, amount = 50) .receive() 

Summary ■ Shared state is evil in a concurrent environment ■ Actor Model fits well in these situations ■ Higher Memory consumption ■ Errors are handled on a higher abstraction level 

Summary ■ Actor Model is not well represented in Kotlin (kotlinx.coroutines) ■ Backpressure in Kotlin can lead to known concurrency issues [..] we do not plan to turn kotlinx.coroutines into an actor-based framework [..]. In terms of kotlinx.coroutines actor is just a code organization pattern -- a coroutine plus an incomming channel. - Roman Elizarov, JetBrains 

Questions? Example can be found here https://gist.github.com/nernsting/ebf5e5c11cdd07ec797e00955ba6dac6