Actor based approach in practice for Swift developers

Thefutureinmobile
Bartosz Polaczyk
Actor based approach in
practice for Swift
developers

Bartosz Polaczyk
Senior iOS Developer
Grand Parade part of William Hill
norapsi
polac24
bartosz@polaczyk.com@

Theory
What actor is
Benefits
iOS Actors
Use cases
Solution
Benefits
Future
Swift language
support
Implementation
Mini framework
Actor sample
Unit tests
Challenges

Proposed in 1973 by Carl Hewitt
Used in distributed, high reliability systems,
telecommunication industry
Successful in Scala (framework Akka)
and C#/F# (Akka.NET)
Intro
Actor

Actor
principles
Has unique address
Receives messages from different sources
Processes one message a time
Reacts by:
Reading/writing local state (memory)
Creating new actor(s)
Sending message(s) to other actors

Actor  
limits
Unidirectional - fire and forget
No global state manipulation
No concurrency within Actor
Messages carry only information
Order of messages is indeterministic

Mail example
Actor
”Bartosz Polaczyk, Street 1, Krakow”

Mail example
Actor
”Bartosz Polaczyk, Street 1, Krakow”
”Bartosz Polaczyk
secretary”

Scaling by distribution
Modularization by design
Efficient concurrency -
no locks
Fault tolerance
Benefits

Asynchronous
problems
[Actor] provides an "island of serialization in a
sea of concurrency".
Chris Lattner, Concurrency in Swift: One approach

class Counter{
private var value = 0
public func add(){
value += 1
}
...
}
class Counter{
private let queue = DispatchQueue()
public func add(){
queue.async{
value += 1
}
}
...
}
class Counter{
public func add(){
queue.async{
value += 1
}
}
public func addTwice() {
queue.async{
value += 2
}
}
public func add(from:TimesProvider){
queue.async{
value += from.value
}
}
Traditional thread-safety API

Developer’s responsibility for
exclusive critical sections calls
#1 Manual queuing
class Counter{
public func add(){
queue.async{
value += 1
}
}
public func addTwice() {
queue.async{
value += 2
}
}
queue.async{
value += from.value
}
}
}
External dependencies (e.g.
arguments) may be thread-unsafe
#2 Dependencies thread-safety
Pitfalls
Traditional way // nonatomic

Calling a function
Swift
Sending a message
Actor

class Counter{
func add(_ value:Int){…}
func subtract(_ value:Int){…}
}
counter.add(1)
class CounterActor {
func send(_ message:CounterMessage){…}
}
enum CounterMessage {
case add(Int)
case subtract(Int)
}
counterActor.send(.add(1))
ActorSwift

• Message may not contain any shared state
• Serialization/deserialization possible
Full value semantics
Actor message
“Codable”
“Codable”
#2 Dependencies thread-safety
Actor

Actor
A
Driver
Message
[Command]

class ActorDriver<Actor:Actorable>{
private let queue:DispatchQueue
private var actor:Actor
private let externals:Actor.Command.Externals
fileprivate init(actor:Actor, externals: Actor.Command.Externals, queue:
DispatchQueue){
self.actor = actor
self.externals = externals
self.queue = queue
}
public func send(_ message:Actor.Message){
queue.async{
self.actor.onReceive(message).forEach{$0.interpret(externals:
self.externals)}
}
}
convenience init(actor:Actor, externals: Actor.Command.Externals){
self.init(actor: actor, externals: externals, queue:
DispatchQueue(label:String(describing:ActorDriver<Actor>.self)))
}
}
• Single function (send)
• Statically typed message
Input
ActorDriver

01
protocol Actorable {
associatedtype Message
associatedtype Command:Commandable where Command.Message ==
Message
mutating func onReceive(_ : Message) -> [Command]
}
protocol Commandable{
associatedtype Message:Messagable
associatedtype Externals
func interpret(externals: Externals, feedback:
@escaping AnyActorDriver<Message> )
}
03
protocol Messagable {} 
02
typealias AnyActorDriver<Message:Messagable> =
(Message) -> ()04
Input + Logic + Output
Actor core logic

typealias AnyActorDriver<Message:Messagable> = (Message) -> ()
Actor Driver type erasure

class ActorDriver<Actor:Actorable>{
private let queue:DispatchQueue
private var actor:Actor
private let externals:Actor.Command.Externals
fileprivate init(actor:Actor, externals: Actor.Command.Externals, queue: DispatchQueue){
self.actor = actor
self.externals = externals
self.queue = queue
}
func send(_ message:Actor.Message){
queue.async{
self.actor.onReceive(message).forEach{$0.interpret(externals: self.externals)}
}
}
convenience init(actor:Actor, externals: Actor.Command.Externals){
self.init(actor: actor, externals: externals, queue:
DispatchQueue(label:String(describing:ActorDriver<Actor>.self)))
}
}
protocol Messagable {}
protocol Actorable {
associatedtype Message
associatedtype Command:Commandable where Command.Message == Message
mutating func onReceive(_ : Message) -> [Command]
}
protocol Commandable{
associatedtype Message:Messagable
associatedtype Externals
func interpret(externals: Externals, feedback: @escaping AnyActorDriver<Message> )
}
Actor framework
snippet

enum Message{
case reloadIntent
case resultsReady(elements:[Element])
}
enum Command {
case loadElements
case presentElements(elements:[Element])
}
enum ListScreenActor: Actorable {
case initial
case loading
case presenting(elements:[Element])
case refreshing(elements:[Element])
mutating func onReceive(_ message: Message) -> [Command] {
switch (message, self) {
case (.reloadIntent,.initial):
self = .loading
return [.loadElements]
case (.reloadIntent, .presenting(let elements)):
self = .refreshing(elements: elements)
case (.resultsReady(let elements), .loading),
(.resultsReady(let elements), .refreshing):
self = .presenting(elements: elements)
return [.presentElements(elements: elements)]
default:
return []
}
}
}
Output
Logic
ListScreenActor
Input
`
UI
.initial
.reloadIntent

enum Message{
case reloadIntent
}
enum Command {
case loadElements
}
case initial
case loading
self = .loading
default:
return []
}
}
}
Output
Logic
ListScreenActor
Input
`
UI
.reloadIntent
.loading

enum Message{
case reloadIntent
}
enum Command {
case loadElements
}
case initial
case loading
self = .loading
default:
return []
}
}
}
Output
Logic
ListScreenActor
Input
`
UI
.loading
.loadElements

enum Message{
case reloadIntent
}
enum Command {
case loadElements
}
case initial
case loading
self = .loading
default:
return []
}
}
}
Output
Logic
ListScreenActor
Input
`
UI
.loading
Network
Actor
.loadElements

enum Message{
case reloadIntent
}
enum Command {
case loadElements
}
case initial
case loading
self = .loading
default:
return []
}
}
}
Output
Logic
ListScreenActor
Input
`
UI
.loading
Network
Actor
.resultsReady

enum Message{
case reloadIntent
}
enum Command {
case loadElements
}
case initial
case loading
self = .loading
default:
return []
}
}
}
Output
Logic
ListScreenActor
Input
`
UI
.loading
Network
Actor
.resultsReady
.reloadIntent

enum Message{
case reloadIntent
}
enum Command {
case loadElements
}
case initial
case loading
self = .loading
default:
return []
}
}
}
Output
Logic
ListScreenActor
Input
`
UI
Network
Actor
.resultsReady
.reloadIntent
.presenting

enum Message{
case reloadIntent
}
enum Command {
case loadElements
}
case initial
case loading
self = .loading
default:
return []
}
}
}
Output
Logic
ListScreenActor
Input
`
UI
Network
Actor
.reloadIntent
.presentElements
.presenting

enum Message{
case reloadIntent
}
enum Command {
case loadElements
}
case initial
case loading
self = .loading
default:
return []
}
}
}
Output
Logic
ListScreenActor
Input
`
UI
Network
Actor
.reloadIntent
.presenting

enum Message{
case reloadIntent
}
enum Command {
case loadElements
}
case initial
case loading
self = .loading
default:
return []
}
}
}
Output
Logic
ListScreenActor
Input
UI
Network
Actor
.reloadIntent
.presenting

Actor A
Driver
Actor B
Non actor C
Actor

Actors unit testing
From async to sync state machine
Actor

enum ListScreenActor {
case initial
case loading
self = .loading
case (.resultsReady(let elements), .presenting):
...
}
}
}
Actor tests
Initialize an actor
Send message/
messages
Observe commands
func testFirstReload_startsLoading(){
var actor = ListScreenActor.initial
let commands = actor.onReceive(.reloadIntent)
XCTAssertEqual(commands, [.loadElements])
}

case initial
case loading
self = .loading
...
}
}
}
Actor tests
Initialize an actor
Send message/
messages
Observe commands
func testLoadedResults_presentElements(){
_ = actor.onReceive(.reloadIntent)
let commands = actor.onReceive(.resultsReady(elements: ["1", "2"]))
XCTAssertEqual(commands, [.presentElements(elements: [“1”,”2”])])
}

func testMultiplereloads_loadOnce(){
let commands1 = actor.onReceive(.reloadIntent)
let commands = actor.onReceive(.resultsReady(elements: ["1", “2"]))
XCTAssertEqual(commands1.onReceive(), ...)
XCTAssertEqual(commands.onReceive(), ...)
}
case initial
case loading
self = .loading
...
}
}
}
Actor tests
Initialize an actor
Send message/
messages
Observe commands

enum Message:Messagable{
case retrievePath(path:String, id: UUID)
...
}
case retrievePath(path:String, completion:(Int)->())
...
}
#1 Completion handlers
• Limitation:
• No reference types in a message
• Solution:
• unique identifier

• Limitation:
• Actor reacts only for messages
• Solution:
• Separate object for sending
message with timer events
enum ScreenActor{
...
switch (message, self){
self = .loading
Timer.scheduledTimer(withTimeInterval: 60 , repeats: false) {_ in
self = .initial
}
...
#2 Timers
…
case timerEvent
…
}

struct Actor:Actorable {
switch message{
...
case .contentError(_):
...
}
}
throw
#3 Error handling
• Limitation:
• No automatic thrown Errors
propagation
• Solution:
• Manual propagation

Chris Lattner Concurrency in Swift: One approach
https://gist.github.com/lattner/31ed37682ef1576b16bca1432ea9f782

Concurrency in Swift:
One approach
actor keyword
reference type
actor Counter{
private let otherActor:OtherActor
actor func add(){
// queue.async{
value += 1
//}
}
actor func addTwice() {
// queue.async{
value += 2
//}
}
value += 2
}
}
Compiler’s addition

// Swift
actor MainActor{
actor private init() {}
}
// App
Extension MainActor{
// App logic
}
Concurrency in Swift:
One approach
support for MainActor
ValueSemantical
protocol
protocol ValueSemantical{
...
}
struct State: ValueSemantical{
let some: SomeType
}

Actor systems
Swift implementation
Address concurrency issues
Potential Swift actor support
Actors
Recap

Thank you
https://github.com/polac24/ActorRecordings

Actor based approach in practice for Swift developers

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Actor based approach in practice for Swift developers

Similar to Actor based approach in practice for Swift developers (20)

Recently uploaded

Recently uploaded (20)

Actor based approach in practice for Swift developers