Swift ) Actor (3) - isolated parameter / nonisolated keyword

📖 Actor (1) 읽으러가기

📚 Actor (2) 읽으러가기

 

안녕하세요 :) Zedd입니다.

Actor (2) - Actor isolation 글에서 Actor isolation을 공부해봤는데요.

오늘은 isolated parameter / nonisolated keyword에 대해서 공부해보겠습니다.

반드시 Actor (2) - Actor isolation 글을 읽고와주세요.

 

# 한계 

Actor (2) - Actor isolation 글에서 BankAccount Actor를 정의했었습니다.

(extension에 있던 Transfer메소드는 제외하고 보도록하죠)

actor BankAccount {
  let accountNumber: Int
  var balance: Double

  init(accountNumber: Int, initialDeposit: Double) {
    self.accountNumber = accountNumber
    self.balance = initialDeposit
  }
  
  func deposit(amount: Double) {
    assert(amount >= 0)
    self.balance = self.balance + amount
  }
}

위 코드에는 한계가 존재합니다.

 

한계 1. deposit메소드는 반드시 actor의 인스턴스로만 접근 할 수 있습니다.

즉, 나는 어떤 계좌 주고 여기에 입금해~ 라고 하고싶을 수 있죠. 

func deposit(amount: Double, to account: ✅ BankAccount ✅) {
  assert(amount >= 0)
  account.balance = account.balance + amount
}

즉 이런식으로 global function을 만들고 싶지만, 그게 안됩니다.

왜인지는 아시죠!?!? 

글에서 봤던 Transfer와 동일한 겁니다.

func deposit(amount: Double, to account: BankAccount) {
  assert(amount >= 0)
  account.balance = account.balance + amount // Actor-isolated property 'balance' can not be referenced from a non-isolated context
}

balance를 참조해야하는데, balance는 actor-isolated 프로퍼티이기 때문이죠.

이건 self를 통해 참조하는 것도 아니어서 cross-actor reference에 해당됩니다.

2번에서 자세히 보도록 합시다.

 

한계 2. actor외부에서 synchronously하게 사용할 수 있는 computed property를 만들 수 없다.

자, BankAccount에 이름을 지정할 수 있고, 

actor BankAccount {
    let accountNumber: Int
    var balance: Double
    let accountName: String ✅
    
    var displayName: String {
        return self.accountName + "안녕하세요" ✅
    }
    
    init(accountNumber: Int,
         initialDeposit: Double,
         accountName: String) {
        self.accountNumber = accountNumber
        self.balance = initialDeposit
        self.accountName = accountName
    }
}

accountName을 받고, displayName은 accountName에 뭔가를 붙혀서 보여주고 싶습니다. 

간단한 computed property네요.

actor BankAccount { ... }

let account = BankAccount(accountNumber: 1,
                          initialDeposit: 100,
                          accountName: "Zedd")
account.displayName // Actor-isolated property 'displayName' can not be referenced from a non-isolated context

actor외부에서 BankAccount 인스턴스를 만들고, displayName을 호출하려고 하면 컴파일 에러가 납니다.

Actor (2) - Actor isolation 글에서 말했듯이, actor에 정의된

- stored, computed instance properties 

- instance methods 

- instance subscripts

는 모두 actor-isolated 상태입니다. 

그리고 지금 account.displayName은 

actor 외부에서 actor-isolated 정의에 대해 참조하는것이기 때문에 cross-actor reference라고 할 수 있습니다. 

cross-actor reference를 하기 위해서는 아래 2가지 조건 중 하나에 반드시 해당해야합니다. 

1. 불변 상태에 대한 cross-actor reference. (같은 모듈 내에서만) 

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

displayName은 let으로 선언되어있지 않기 때문에 1번에는 해당이 안되므로 반드시 비동기로 호출해야합니다.

즉, 

actor BankAccount { ... }

let account = BankAccount(accountNumber: 1,
                          initialDeposit: 100,
                          accountName: "Zedd")
await account.displayName ✅

await과 함께 호출해야하며, 위 코드도 어느 함수 내에서 불릴테니 함수를 async로 만들거나, async 핸들러 내에서 호출해야겠죠. 

그러니까 결론은 불편하다는겁니다.

actor 외부이긴 하지만 displayName정도는 그냥 synchronously하게 호출하고 싶잖아요? 

 

한계 3. Hashable conform 불가

actor BankAccount {
    ... 
    
    static func someStaticThing() {
        //
    }
}

BankAccount.someStaticThing() ✅

BankAccout안에 있는 static 프로퍼티나 메소드는 actor-isolated 하지 않습니다. 

즉, actor외부에서 별다른 제약없이 호출이 가능합니다.

BankAccount가 Equatable을 준수하도록 해주겠습니다.

extension BankAccount: Equatable {
    
    static func == (lhs: BankAccount, rhs: BankAccount) -> Bool {
        return lhs.accountNumber == rhs.accountNumber
    }
}

필요한 static 메소드를 구현해줬습니다. 

accountNumber는 let. 즉 불변상태의 접근이었고, ==는 static 메소드이기 때문에 위 정의는 문제가 없습니다.

(만약 비교에 balance를 넣었으면 컴파일이 안됐겠지만요.) 

 

BankAccount가 Hashable을 준수해주도록 하겠습니다.

extension BankAccount: Hashable {

    func hash(into hasher: inout Hasher) {
        hasher.combine(self.accountNumber) // Actor-isolated instance method 'hash(into:)' cannot be used to satisfy a protocol requirement
    }
}

WWDC21 Protect mutable state with Swift actors 를 보면

오류메시지가 이렇게 났던 것 같은데..아무튼 Xcode13 Beta 5 기준으로 

 Actor-isolated instance method 'hash(into:)' cannot be used to satisfy a protocol requirement

이렇게 나옵니다.

 

자 왜 컴파일 에러가 날까요?

Swift 컴파일러 : BankAccount가 Hashable을 준수했어? 그럼 이 hash(into:)는 actor외부에서 호출될 수 있겠군...

하지만 hash(into:)는 비동기가 아니니까 actor-isolated를 유지 할 수 없어! 

Actor-isolated instance method 'hash(into:)' cannot be used to satisfy a protocol requirement

도 그걸 나타내고 있죠.

actor의 instance method는 기본적으로 actor-isolated 상태인데, 

Actor-isolated인 메소드 hash(into:)는 protocol requirement를 충족하는데 사용할 수 없다. 

인겁니다.

이게 3번째 한계입니다.

Hashable을 준수할 수 없다는건, Set<BankAccount>를 만들 수 없다는 걸 의미합니다. 

 

# 원인 

자..한계점들을 간단히 요약해보면,

1. deposit메소드는 반드시 actor의 인스턴스로만 접근 할 수 있습니다.

2. actor외부에서 synchronously하게 사용할 수 있는 computed property를 만들 수 없다.

3. Hashable conform 불가

위 3개다 원인이 뭐였나요?! 다 그놈의 actor-isolated 때문인겁니다 (분노) 

actor의 정의된

- stored, computed instance properties 

- instance methods 

- instance subscripts

들이 기본적으로 actor-isolated 상태라는 사실에서 비롯된 한계점들입니다.

 

🙋 : 그래 actor-isolated인 상태가 중요하단건 알겠어 ㅎ 근데 actor-isolated 안하게 만들 순 없나? 

🧑‍💻 : ㅋㅋ쌉가능

 

# 개선

그래서 이 proposal은

1. 함수의 파라미터 중 어떤것이 isolated인지 표시하거나

2. 선언 자체를 actor로 부터 isolated하지 않음으로써

actor-isolated를 선택할 수 있도록 합니다.

 

# isolated parameter 

한계점 중 1번을 개선해보겠습니다. 

deposit을  global function으로 만드는거였죠? 

func deposit(amount: Double, to account: BankAccount) {
  assert(amount >= 0)
  account.balance = account.balance + amount // ❌ Actor-isolated property 'balance' can not be referenced from a non-isolated context
}

위 코드는 

actor-isolated property인 balance는 non-isolated context에서 참조될 수 없어 ㅎ 하고 에러를 냅니다. 

이게 돌아가게 하려면 이 함수가 isolated context를 가지게 하면 됩니다. 

func deposit(amount: Double, to account: ✅ isolated ✅ BankAccount) {
  assert(amount >= 0)
  account.balance = account.balance + amount
}

함수의 파라미터에  isolated 표시가 되었습니다. 

✔️ 함수는 파라미터 중 하나가 isolated 표시가 되면 actor-isolated가 된다.

즉, deposit은 actor 외부에 정의되어있으므로 원래는 actor-isolated가 아닙니다.

근데 account 파라미터에 isolated로 표시하게 되면서, deposit은 actor-isolated 함수가 된겁니다.

func deposit(amount: Double, to account: isolated BankAccount) {
  assert(amount >= 0)
  account.balance = account.balance + amount ✅
}

원래 에러가 났던 저 코드도 에러가 나지 않습니다. 

왜냐? 이제 deposit이 isolated context를 갖기 때문이죠.

그래서 account.balance. 즉 actor-isolated 상태에 직접 접근을 할 수 있게 된겁니다.

 

# nonisolated 

파라미터를 isolated로 표시하는게 모든 한계점을 해결해주는 건 아닙니다.

예를 들어 한계점 중 2번인

2. actor외부에서 synchronously하게 사용할 수 있는 computed property를 만들 수 없다.

는 여전히 있죠. 이러한 한계점을 해결하기위한 nonisolated 키워드가 있습니다.

actor BankAccount {
    let accountNumber: Int
    var balance: Double
    let accountName: String
    
    ✅ nonisolated ✅ var displayName: String {
        return self.accountName + "안녕하세요"
    }
        
    init() { ... }
}

nonisolated 키워드는 위 코드처럼 프로퍼티나 함수의 정의 앞에 붙힐 수 있습니다. 

actor에 정의된

- stored, computed instance properties 

- instance methods 

- instance subscripts

는 기본적으로 actor-isolated상태인데, nonisolated를 붙히게 되면 이 동작을 비활성화 할 수 있게 됩니다.

actor BankAccount {
    let accountNumber: Int
    var balance: Double
    let accountName: String
    
    nonisolated var displayName: String {
        return self.accountName + "안녕하세요"
    }
}
let account = BankAccount(accountNumber: 1,
                                      initialDeposit: 100,
                                      accountName: "Zedd")
print(account.displayName) // Zedd안녕하세요 ✅

즉, 이렇게 displayName에 대해 동기적 참조가 가능해집니다.

 🤯 : 아 ㅋㅋ actor-isolated 개답답했는데

actor BankAccount {
    nonisolated let accountNumber: Int
    nonisolated var balance: Double
    nonisolated let accountName: String
    
    nonisolated var displayName: String {
        return self.accountName + "안녕하세요"
    }
}

다 nonisolated 해버려ㅡㅡ

🧑‍💻 : 응 안돼

actor BankAccount {
    nonisolated let accountNumber: Int
    nonisolated var balance: Double // ❌ Nonisolated' can not be applied to stored properties
    nonisolated let accountName: String
    
    nonisolated var displayName: String {
        return self.accountName + "안녕하세요"
    }
}

balance쪽에서 컴파일 에러가 나는데요. 에러는

Nonisolated' can not be applied to stored properties

이렇게 나오지만..

balance가 let이 아닌 var이고 concurrent code에서 data race가 발생할 수 있으므로 막아놓은 것 같습니다 ㅎ

 

nonisolated로 인해 한계점 중 3번도 해결 가능!

extension BankAccount: Hashable {
    
  ✅ nonisolated ✅ func hash(into hasher: inout Hasher) {
    hasher.combine(accountNumber)
  }
}

---

참고 (나중에 Xcode 13 정식 릴리즈 되면 확인해볼 것.) 

요 부분..proposal에서는 별다른 언급은 안되는데 ㅜㅜ.. Xcode 13 Beta 5에서 컴파일이 안됩니다. 

원인은

Actor-isolated property 'hashValue' cannot be used to satisfy a protocol requirement
Add 'nonisolated' to 'hashValue' to make this property not isolated to the actor

인데요..

Swift 4.1에서 hashValue는 모든 프로퍼티가 각각 Equatable 또는 Hashable을 준수하면, 꼭 구현해주지 않아도 되었고,

하물며 지금은 hashValue가 deprecated 인 상태인데요. 

hashValue 문서 참고 : https://developer.apple.com/documentation/swift/hashable/1540917-hashvalue

왜 이런 에러가 나는지 모르겠네요 ㅜㅜ...

결국 hashValue도 선언해서 nonisolated로 해주니까 

extension BankAccount: Hashable {
    
    nonisolated func hash(into hasher: inout Hasher) {
        hasher.combine(accountNumber)
    }
    
    nonisolated var hashValue: Int {
        return accountNumber.hashValue ^ accountNumber.hashValue &* 16777619
    }
}

컴파일이 되긴 하네요! 참고하시길 ㅎㅎ

---

Actor안에 정의되어있는 인스턴스 메소드를 nonisolated로 하기 전에는 주의해야합니다.

extension BankAccount {
    func steal(amount: Double) {
      self.balance -= amount 
    }
}

self를 통해 balance에 접근하는 것이기 때문에 위 코드는 문제가 없었는데, 이걸 nonisolated로 해버리면

extension BankAccount {
    ✅ nonisolated ✅ func steal(amount: Double) {
      self.balance -= amount // 🚨 error: actor-isolated property 'balance' can not be referenced on non-isolated parameter 'self'
    }
}

에러가 납니다. balance가 actor-isolated 프로퍼티인건 맞지만, 요 메소드가 actor-isolated가 아니기 때문에 발생하는 에러에요! 

그러니까 self여도 더이상 접근을 못하게 되는것이죠. 

 

그리고 하나 더! Actor (2) - Actor isolation 글에서 

actor BankAccount {
    let accountNumber: Int
    ...
}

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

불변 상태에 대한 cross-actor reference는 같은 모듈 내에서만 적용이 되었고,

위 코드 처럼 다른 모듈에서는 accountNumber가 불변 상태여도 비동기로 참조해야합니다.

actor BankAccount {
    public nonisolated let accountNumber: Int
    ...
}

// 다른 모듈
func outside_moudle_method() { 
    let account = BankAccount(accountNumber: 1, initialDeposit: 10) 
    print(account.accountNumber) ✅ 
}

하지만 accountNumber가 nonisolated면 다른 모듈에서도 동기적으로 참조가 가능합니다.

nonisolated의 기능으로 보면 당연한거죠?!

 

휴! 오늘 공부한 부분도 Improved control over actor isolation를 많이 참고했어요 ㅎㅎ 

틀린 부분이 있다면 댓글 달아주세요. 

다음글은 아마도 Sendable이 되지 않을까!