Concurrency Concepts

Isolated State

Concurrent programs keep mutable state behind a small boundary.

Update through one boundary

amount
isolated_state.swift
Replay: real traced execution (multi-file project)
struct CounterState {
    var value = 0

    mutating func add(_ amount: Int) {
        value += amount
    }
}

let amount = 3
var state = CounterState()
state.add(amount)
let message = "counter=\(state.value)"

print(message)

struct CounterState {
    var value = 0

    mutating func add(_ amount: Int) {
        value += amount
    }
}

let amount = 1
var state = CounterState()
state.add(amount)
let message = "counter=\(state.value)"

print(message)

struct CounterState {
    var value = 0

    mutating func add(_ amount: Int) {
        value += amount
    }
}

let amount = 6
var state = CounterState()
state.add(amount)
let message = "counter=\(state.value)"

print(message)

  1. amount ← 3, state ← CounterState(value: 0)

    9let amount→ 3 = 3  //@amount=1, 610var state→ CounterState(value: 0) = CounterState()11stateCounterState(value: 0).add(amount3)12let message = "counter=\(state.value)"

  2. value ← 3

    4mutating func add(_ amount3: Int) {5    value→ 3 += amount36}

  3. state ← CounterState(value: 3), message ← counter=3

    10var state = CounterState()11state→ CounterState(value: 3).add(amount3)12let message→ counter=3 = "counter=\(state.value3)"1314print(messagecounter=3)
    outputcounter=3

  1. amount ← 1, state ← CounterState(value: 0)

    9let amount→ 1 = 110var state→ CounterState(value: 0) = CounterState()11stateCounterState(value: 0).add(amount1)12let message = "counter=\(state.value)"

  2. value ← 1

    4mutating func add(_ amount1: Int) {5    value→ 1 += amount16}

  3. state ← CounterState(value: 1), message ← counter=1

    10var state = CounterState()11state→ CounterState(value: 1).add(amount1)12let message→ counter=1 = "counter=\(state.value1)"1314print(messagecounter=1)
    outputcounter=1

  1. amount ← 6, state ← CounterState(value: 0)

    9let amount→ 6 = 610var state→ CounterState(value: 0) = CounterState()11stateCounterState(value: 0).add(amount6)12let message = "counter=\(state.value)"

  2. value ← 6

    4mutating func add(_ amount6: Int) {5    value→ 6 += amount66}

  3. state ← CounterState(value: 6), message ← counter=6

    10var state = CounterState()11state→ CounterState(value: 6).add(amount6)12let message→ counter=6 = "counter=\(state.value6)"1314print(messagecounter=6)
    outputcounter=6
isolated state This small type models the same idea actors enforce: callers update state through a method instead of changing storage from many places.