Swift ) Actor (2) - Actor isolation

 

📖 Actor (1) 읽으러가기

 

# Actor 특징 복습 📝

- Actor는 그냥 Swift의 새로운 타입임. 클래스와 가장 유사. 

- Swift의 다른 모든 타입들과 똑같이 프로퍼티, 메소드, 이니셜라이저, subscripts 등을 가질 수 있음.

- 프로토콜 준수, Extension 역시 쌉가능

- 참조타입 like class

- 클래스와 달리 Actor는 한번에 하나의 작업만 변경 가능한 상태(mutable state)에 접근할 수 있도록 허용.

- 클래스와 달리 상속을 지원하지 않음.

 

# Actor isolation

우리가 사실 immutable state면 Actor를 쓸 필요도 없잖아요? 

근데 지금 (Shared) mutable state여서 지금 문제가 발생할 여지가 있는거ㅇㅇ

그래서 우리가 Actor라는 걸 쓰는거고.

Actor가 mutable state에 동시에 접근하지 않도록 하니까! Swift가 근본적으로 보증하니까!

🤷: 근데 Actor 니가 뭔데,,니가 어떻게 보호하겠다는건데..그거 어떻게 하는건데

🧑‍💻: Actor isolation. Actor isolation은 Actor가 mutable state를 보호하는 방법임.

🤷 : 정확히 어떻게 보호하는디

 

예를 들어보자. BankAccount라는 Actor가 있음.

actor BankAccount {
  let accountNumber: Int
  var balance: Double

  init(accountNumber: Int, initialDeposit: Double) {
    self.accountNumber = accountNumber
    self.balance = initialDeposit
  }
}

그리고 BankAccount을 extension했어 

extension BankAccount {
  enum BankError: Error {
    case insufficientFunds
  }
  
  func transfer(amount: Double, to other: BankAccount) throws {
    if amount > self.balance {
      throw BankError.insufficientFunds
    }

    print("Transferring \(amount) from \(accountNumber) to \(other.accountNumber)")

    self.balance = balance - amount
    other.balance = other.balance + amount  // error: actor-isolated property 'balance' can only be referenced on 'self'
  }
}

extension에는 transfer(amount: to :) 메소드가 있음. 

func transfer(amount: Double, to other: BankAccount) throws {
  if amount > self.balance {
    throw BankError.insufficientFunds
  }

  print("Transferring \(amount) from \(accountNumber) to \(other.accountNumber)")

  self.balance = balance - amount ✅
  other.balance = other.balance + amount ✅
}

자 balance를 업데이트 시키는 곳을 보자.

 

자 만약에 BankAccount가 class였으면 

1. 위 코드는 문제가 없고 == 컴파일 에러가 안나고

2. concurrent code에서 data races를 발생시킬 수 있음.

왜냐? balance를 업데이트 시키니까. 

 

근데 BankAccount가 지금 actor잖아??

func transfer(amount: Double, to other: BankAccount) throws {
  if amount > self.balance {
    throw BankError.insufficientFunds
  }

  print("Transferring \(amount) from \(accountNumber) to \(other.accountNumber)")

  self.balance = balance - amount ✅
  other.balance = other.balance + amount 🚨 // error: actor-isolated property 'balance' can only be referenced on 'self'
}

other.balance를 업데이트 시키는 쪽이 컴파일에러가 남. 

왜냐면 balance는 self에서만 참조될 수 있기 때문!!!!! 

other.balance 이렇게 참조만해도 에러가남. 

에러를 자세히 보자 

actor-isolated property 'balance' can only be referenced on 'self'

1. actor-isolated property 'balance'

🙋: balance 프로퍼티가 actor-isolated property인가보군..

🧑‍💻 : (두둥) 사실입니다. 

actor내에 정의된

- stored, computed instance properties

- instance methods

- instance subscripts

는 기본적으로 모두 actor-isolated 상태이다.

 

2. can only be referenced on 'self'

actor-isolated 친구들은 연결되거나 "격리된" 특정 actor내에서 접근할 수 있는데, 그게 self다.

그러니까 actor-isolated 친구들은 기본적으로 self를 통해서만 접근이 가능하다는 뜻이다. 

 

특1. actor-isolated 정의들은 다른 actor-isolated 정의들을 자유롭게 참조 할 수 있다.

특2. actor-isolated가 아닌 정의들은 actor-isolated 정의들에 동기적으로 접근할 수 없다. 

 

# cross-actor reference

actor 외부에서 actor-isolated 정의에 대해 참조하는 것을 cross-actor reference라고 한다.

이러한 참조는 2가지 방법중 하나로 허용된다.

 

1. 불변 상태에 대한 cross-actor reference.

actor가 정의된 동일한 모듈의 어느 곳에서나 항상 허용. 

(한 번 초기화되면 해당 상태는 actor 내부에서든, 외부에서든 수정할 수 없기 때문에)

 

🙋: 질문!

actor BankAccount {
  let accountNumber: Int
  var balance: Double

  init(accountNumber: Int, initialDeposit: Double) {
    self.accountNumber = accountNumber
    self.balance = initialDeposit
  }
}

BankAccount에는 accountNumer랑 balance가 있잖아!

아까

other.balance 🚨 // error: actor-isolated property 'balance' can only be referenced on 'self'

 

이렇게 balance를 참조만 해도 에러났으니까 

ohter.accountNumber

이것도 에러나겠네? 

🧑‍💻: 아니다. 

func transfer(amount: Double, to other: BankAccount) throws {
  if amount > self.balance {
    throw BankError.insufficientFunds
  }

  print("Transferring \(amount) from \(accountNumber) to \(other.accountNumber)")

  self.balance = balance - amount ✅
  other.accountNumber ✅
}

other의 accountNumber에 접근하는건 괜찮음. 

왜냐? 

accountNumber는 let으로 선언되어있기 때문에 불변 상태에 대한 cross-actor reference에 해당된다.

 

🚨 [주의] 🚨

actor가 정의된 동일한 모듈의 어느 곳에서나 항상 허용. 

즉, actor가 정의된 모듈이 아닌 다른 모듈에서는 허용이 안된다는 뜻이다. 

예를 들어보자.

public actor BankAccount {
    public let accountNumber: Int
    public var balance: Double

    public init(accountNumber: Int, initialDeposit: Double) {
    self.accountNumber = accountNumber
    self.balance = initialDeposit
  }
}


// Same module
public class MyStaticLibrary {

    public init() {
        let account = BankAccount(accountNumber: 1, initialDeposit: 10)
        print(account.accountNumber) ✅
    }
}

이렇게 같은 모듈안에 정의되어있으면 accountNumber가 let이므로 접근이 가능하다.

하지만, 외부 모듈에서는

func outside_moudle_method() ✅ async ✅ {
    let account = BankAccount(accountNumber: 1, initialDeposit: 10)
    print(✅ await ✅ account.accountNumber) ✅
}

반드시 비동기 호출로 참조해야한다. 

 

🤷 : 아니 왜 이런..?

🧑‍💻 : 만약에 BankAccount가 정의되어있는 모듈을 사용하는 클라이언트가 있다고 쳐보자.

내가 accountNumber를 let으로 선언해서 클라이언트 코드에는

print(account.accountNumber) ✅

그냥 이런 코드가 있어.

근데 내가 모종의 이유로 인해서 accountNumber를 var로 바꿔야한다고 쳐보자?

근데 var는 비동기 호출만 돼 (외부에서 참조해야하니까) 

즉,  BankAccount모듈을 쓰는 클라이언트 코드가 전부 바뀌어야한다는 소리..

 

그러니까 그런 일이 발생하지 않도록, 즉 클라이언트는 영향을 받지 않도록

모듈 외부에서는 let이든 var든 비동기로 참조해야한다는거!

 

1. 불변 상태에 대한 cross-actor reference. ✅

2. 비동기 함수 호출로 수행되는 형식

비동기 함수 호출은 actor가 안전하게 수행할 수 있을 때 해당작업을 실행하도록 요청하는 "메시지"로 바뀐다.

이러한 메시지는 actor의 메일박스에 저장되며,

비동기 함수 호출을 시작한 호출자는 actor가 메일박스에서 해당 메시지를 처리할 수 있을때 까지 일시중단될 수 있다. 

actor는 메일박스의 메시지를 순차적으로 처리하므로, 궁극적으로 actor는 2개 이상의 동시에 실행되는 작업을 실행할 수 없다. 

즉, 코드 자체에 동시성이 없어지게 때문에 Data race가 발생하지 않게 된다. 

 

자, 예를 들어보자.

내가 이체를 했으니까 

func transfer(amount: Double, to other: BankAccount) throws {
  if amount > self.balance {
    throw BankError.insufficientFunds
  }

  print("Transferring \(amount) from \(accountNumber) to \(other.accountNumber)")

  self.balance = balance - amount ✅
  other.balance = other.balance + amount 🚨 // error: actor-isolated property 'balance' can only be referenced on 'self'
}

내 잔액은 이체한 양 만큼 줄어들어야 하고, 

내가 이체한 다른 계좌의 잔액은 내가 이체한 양만큼 늘어나야한다.

하지만, balance는 actor-isolated 프로퍼티이기 때문에..self가 아닌 other로 balance에 접근을 못하는 상황.

이걸 2번으로 해결해보자.

extension BankAccount {
  func deposit(amount: Double) ✅ async ✅ {
    assert(amount >= 0)
    balance = balance + amount
  }
}

먼저 BankAccount에 deposit이라는 메소드를 만드는데, async로 선언해준다.

그리고 

func transfer(amount: Double, to other: BankAccount) ✅ async ✅ throws {
  if amount > self.balance {
    throw BankError.insufficientFunds
  }

  print("Transferring \(amount) from \(accountNumber) to \(other.accountNumber)")

  self.balance = balance - amount 
  await other.deposit(amount: amount) ✅
}

 other의 deposit을 호출해준다.

deposit이 async로 정의되어있으니 await으로 호출해주자.

transfer내에서 async메소드를 호출해야하기 때문에 transfer는 async로 정의해줘야한다. 

위에서 메시지/메일박스로 예를 들었으니 

await other.deposit(amount: amount) ✅

이것을 메시지/메일박스로 바꿔 말해보자. 

1. deposit이 메시지가 되며

2. other actor의 메일박스에 들어가게 된다.

3.  other actor는 메일박스에서 작업을 검색하여(retrieves the operation) 실행한다.

4. other의 balance가 업데이트 된다. 

 

cross-actor reference를 하는 방법에 대해서 전부 알아보았다. 

1. 불변 상태에 대한 cross-actor reference. ✅

2. 비동기 함수 호출로 수행되는 형식 ✅

 

# Compile-time actor-isolation checking

컴파일 시간에 이루어지는 actor-isolation checking은 

1. cross-actor references인지 확인하고

2. 이러한 참조가 위에서 설명한 2가지 메커니즘 중 하나를 사용하도록 한다.

이렇게 하면 actor 외부의 코드가 actor의 mutable state를 방해하지 않는다.

그러니까 이것이!!!!!!!!!!!!!

진짜 이걸 개길게 말했는데, 이게 Actor가 mutable state를 보호하는 방법인거. 

 

# Advanced

위에서 deposit을 async로 구현했었다. 

extension BankAccount {
  func deposit(amount: Double) ✅ async ✅ {
    assert(amount >= 0)
    balance = balance + amount
  }
}

하지만 잘 보면, deposit은 async로 구현 될 필요는 없다.

(deposit안에서 await를 호출하는것도 아니라서)

따라서 이 경우에는

extension BankAccount {
  func deposit(amount: Double) {
    assert(amount >= 0)
    balance = balance + amount
  }
}

동기함수(sync)로 정의하는 것이 더 낫다. 

🤷: 아니

await other.deposit(amount: amount) ✅

이렇게 await 했는데, async로 선언되어야 하는거 아니야? 컴파일 에러 안나?

🧑‍💻 : ㅇㅇ안나..

func non_async_method() {}

func zedd() async {
    await non_async_method()
}

async 안에서 await + sync 함수를 호출하는건 컴파일 에러에 해당이 안된다. 

다만

No 'async' operations occur within 'await' expression

이런 경고가 뜰 뿐...

await other.deposit(amount: amount) ✅

extension BankAccount {
  func deposit(amount: Double) {
    assert(amount >= 0)
    balance = balance + amount
  }
}

요건 그런 경고도 안뜬다.

이유를 알아보자. 

위에서 계속 봤듯이 BankAccount는 actor로 정의되어있다. 

actor BankAccount {..}

extension BankAccount {
  func deposit(amount: Double) {
    assert(amount >= 0)
    balance = balance + amount
  }
}

deposit은 그런 actor 타입 안의 sync 메소드이다.

sync 메소드여도 

actor 외부에서는 아래처럼 await 키워드와 함께 써야하지만, 

// actor 외부 
let account = BankAccount(accountNumber: 1, initialDeposit: 100)
await account.deposit(amount: 10)

actor 내부에서는 동기적으로 호출할 수 있다. 즉 await 키워드를 같이 써주지 않아도 된다.

하지만 cross-actor reference 일때는!!!!!!!! 비동기 호출이 필요하다. 즉, await과 함께 써야한다.

1. actor 내부에서는 동기적으로 호출할 수 있다.

extension BankAccount {
  // Pass go and collect $200
  func passGo() {
    self.deposit(amount: 200.0)  // synchronous is okay because `self` is isolated
  }
}

2. cross-actor reference 일때는 비동기 호출이 필요하다.

func transfer(amount: Double, to other: BankAccount) ✅ async ✅ throws {
  if amount > self.balance {
    throw BankError.insufficientFunds
  }

  print("Transferring \(amount) from \(accountNumber) to \(other.accountNumber)")

  self.balance = balance - amount 
  await other.deposit(amount: amount) ✅
}

 

사실 Actor의 존재는 너무나도..큰 변화이기 때문에 

WWDC 21 Protect mutable state with Swift actors를 보면서..꽤 오랫동안 써오던 글인데요. 

요 Actor isolation에 부딪혀서 ㅜㅜ 진짜 도무지 이해가 안가서 개짱난다..안해 ** 이상태로 몇주... 

swift-evolution의 actor proposal을 보니까 어느정도 이해가 갑니다.

🤔 여전히 헷갈리는 부분은 있지만 ㅎㅎ...

혹시 틀린점이 있다면 댓글 달아주세요 🙇‍♀️

 

[다음 글 읽으러가기]

Actor (3) - isolated parameter / nonisolated keyword