[Swift] 동시성 프로그래밍(async/await, actor, sendable)

동기 & 비동기

synchronous는 작업을 동기적으로 실행. 실행 중인 작업이 끝날 때 까지 다른 작업을 기다림

asynchronous는 비동기로 현재 실행 중인 작업이 있어도 다른 작업을 실행 할 수 있다. 오래 걸리는 작업을 비동기로 처리해서 메인 스레드에서 필요로 하는 작업이 멈추지 않게 한다.

 

MainActor

UI 관련 작업은 메인 스레드에서 실행되어야 하는데, MainActor는 이를 쉽게 관리할 수 있게 해준다. UI 업데이트와 관련된 작업을 메인 스레드에서 실행하도록 보장한다. 비동기 작업에서 메인 스레드로의 접근을 안전하게 관리하기 때문에 스레드 안정적이며 DispatchQueue.main.async와 같은 코드를 작성할 필요가 없어 간결한 코드를 작성할 수 있다. 

struct DefaultProductDetailUseCase: ProductDetailUseCase {
    func fetchProductDetail(idx: Int) async throws -> Product {
        let (data, response) = try await URLSession.shared.data(from: URL(string: "https://dummyjson.com/products/\(idx)")!)
        guard let response = response as? HTTPURLResponse,
              (200..<300).contains(response.statusCode) else {
            throw CustomError.statusCodeError
        }
        
        guard let result = try? JSONDecoder().decode(Product.self, from: data) else {
            throw CustomError.invalidResponse
        }
        
        return result
    }
}

 

비동기 작업을 수행하는 함수가 있다고 할 때 ViewModel에서 아래와 같이 사용할 수 있다. 

 

class ProductDetailViewModel: ObservableObject {
    var useCase: ProductDetailUseCase?
    
    @Published var product: Product?
    
    init(useCase: ProductDetailUseCase) {
        self.useCase = useCase
    }
    
    func getchProductDetail(idx: Int) {
        Task {
            let product = try await self.useCase?.fetchProductDetail(idx: idx)
            await updateUI(with: product)
        }
    }
    
    @MainActor
    private func updateUI(with product: Product?) async {
        self.product = product
    }
}

 

MainActor을 사용해서 메인 스레드에서 동작해야 하는 코드를 실행한다. 비동기 작업 후 UI 업데이트 코드를 메인 스레드에서 안전하게 실행할 수 있다. 

 

Async

비동기 처리를 수행하는 함수를 정의하려면 async 키워드를 사용해 준다. 

    func fetchProductDetail(idx: Int) async -> Product {
		// 생략
    }

 

async 코드는 concurrent 컨텍스트에서만 실행 가능하다. Task 혹은 다른 async 함수에서 async 함수를 호출할 수 있다. 

에러를 반환할 수 있는 경우 async throws로 정의해 준다. 

    func fetchProductDetail(idx: Int) async throws -> Product {
		// 생략
    }

 

Await

        Task {
            let product = try await self.useCase?.fetchProductDetail(idx: idx)
            await updateUI(with: product)
        }

 

async 함수를 호출하기 위해서 await 키워드를 사용한다. await으로 마킹된 곳은 potential suspension point(잠재적인 일시 중단 지점)으로 지정된다. 즉 이 함수를 호출한 부분도 대기 상태가 될 수 있다는 것을 의미한다. 

여기서 suspension point 의 suspend란 스레드를 block 시키는 것이 아니라 다른 동작을 수행할 수 있도록 컨트롤을 포기하는 것을 의미한다. 스레드에 대한 제어권을 system에게 전달하게 되고, 시스템은 해당 스레드를 사용해 다른 작업을 수행할 수 있다. 이후 시스템은 다른 특정 스레드 제어권을 전달해서 suspension point 이후 코드를 수행할 수 있게 한다. 

 

task

다른 Task와 함께 동시에 실행 할 수 있는 비동기 컨텍스트를 제공한다. SwiftUI에서는 task view modifier를 제공하고 있다. 

    @inlinable public func task(priority: TaskPriority = .userInitiated, _ action: @escaping @Sendable () async -> Void) -> some View

 

task modifier는 아래와 같이 사용한다. 

        VStack { 생략 }
        .task {
            do {
                try await vm.getProductDetail(idx: 1)
            } catch {
                print("error!")
            }
        }

 

getProductDetail(idx:)는 error를 반환 할 수 있는 async throw 이기 때문에 task modifier 내부에서 try catch를 사용한다. 만약 task modifier가 아닌 Button을 눌렀을 때와 같은 동작 이후에 수행되야 한다면 Task.init() 를 사용할 수 있다. 

@frozen public struct Task<Success, Failure> : Sendable where Success : Sendable, Failure : Error {
}

 

initializer는 task modifier와 동일하다. 

@discardableResult
public init(priority: TaskPriority? = nil, operation: @escaping @Sendable () async -> Success)

 

 

            Button {
                Task {
                    do {
                        try await vm.getProductDetail(idx: 1)
                    } catch {
                        
                    }
                }
            } label: {
                Text("버튼으로 실행 할 경우")
            }

 

Task로 생성된 작업은 백그라운드 스레드에서 즉시 실행되며 await 키워드로 해당 지점에서 완료된 값이 돌아올 때까지 기다릴 수 있다. 

 

---

inout paramters

concurrency랑 관련된건 아니지만 자주 나와서 정리하자면, inout은 Swift 내에 정의된 키워드.

함수에 값을 전달할 때 매개변수를 사용하게 되는데 이때 매개 변수의 값을 변경해도 원래 변수 값에 영향을 미치지 않는다. inout을 사용하면 함수의 파라미터 값 변경사항을 원본 변수에 적용할 수 있다. 

 

class ProductDetailViewModel: ObservableObject {
    
    @Published var product: Product?
    
    func removeCurrentProduct() {
        self.removeProductRequest(product: &product)
    }
    
    private func removeProductRequest(product: inout Product?) {
        product = nil
    }
    
    // product를 fetch하는 코드는 제외됨
}

 

SwiftUI의 View에서 removeCurenProduct를 호출하면 viewModel 내부에 정의된 private 함수인 removeProductRequest를 호출한다. 이때 파라미터로 inout 매개변수를 전달한다. 전달받은 매개변수의 값을 변경하면 viewModel의 원본 변수인 @Published로 정의된 product의 값이 nil로 변경된다.

 

            Button {
                vm.removeCurrentProduct()
            } label: {
                Text("상품 정보 제거하기")
            }
            .buttonStyle(.borderedProminent)
            
            Text(vm.product?.title ?? "")

 

View 코드로 원본 product 값의 변경을 확인할 수 있다. 

removeProductRequest(product: &product)

 

매개변수 전달시 &(ampersand)을 사용한다. 이는 매개변수가 inout으로 사용되고 있음을 명시적으로 알려준다.

 

Isolated Actor

• 동시성을 안전하게 관리하기 위한 타입
• Actor 내의 데이터는 다른 스레드나 컨텍스트에서 접근 할 수 없지만 특정 메서드나 프로퍼티를 isolated로 표시하면 해당 actor의 상태에 접근하고 수정할 수 있음
• 모든 Actor 타입은 암묵적으로 Sendable을 따른다. actor는 mutable state에 대한 isolation을 보장한다.

Sendable

• Sendable 타입을 준수하는 타입은 해당 타입의 인스턴스를 스레드 간 안전하게 전달 할 수 있음
• Value Type은 내부적으로 Sendable 프로토콜을 따르므로 스레드의 안전을 보장한다. 
• Reference Type은 final 클래스 혹은 클래스 내 상수 타입으로 선언하여 Sendable 프로토콜을 사용할 수 있다. 

(어디에 사용될 수 있을지는 잘 모르겠다🤔)

  public static func run(
    priority: TaskPriority? = nil,
    operation: @escaping @Sendable (_ send: Send<Action>) async throws -> Void,
    catch handler: (@Sendable (_ error: Error, _ send: Send<Action>) async -> Void)? = nil,
    fileID: StaticString = #fileID,
    line: UInt = #line
  ) -> Self

 

• TCA에서 비동기 처리 이후 Effect를 반환하기 위해 .run을 사용하는데 이때 operation에 @Sendable이 들어가 있다(TCA하다가 여기까지 왔당 ㅋㅋㅋ ㅠㅠ)

struct SendableLibraryStruct: Sendable {
    var name: String
    var bookCount: Int
}

• 값 타입인 구조체는 Sendable을 준수해준다.

final class SendableLibraryClass: Sendable {
    let name: String
    let bookCount: Int
    
    init(name: String, bookCount: Int) {
        self.name = name
        self.bookCount = bookCount
    }
}

• 참조 타입인 class는 final class여야 하고 Sendable을 준수해 준다.

actor SendableTestActor {
    private var libraryStruct = SendableLibraryStruct(name: "", bookCount: 0)
    private var libraryClass = SendableLibraryClass(name: "", bookCount: 0)
    
    func updateDataWithStruct(libraryInfo: SendableLibraryStruct) {
        self.libraryStruct = libraryInfo
    }
    
    func updateDataWithClass(libraryInfo: SendableLibraryClass) {
        self.libraryClass = libraryInfo
    }
    
    func getNameFromClass() async throws -> String {
        try await Task.sleep(until: .now + .seconds(1), clock: .continuous)
        return libraryClass.name
    }
    
}

• actor는 동시성 접근을 안전하게 관리한다.
• 내부의 데이터는 다른 스레드나 실행 컨텍스트에서 직접 접근할 수 없다.
• 특정 메서드나 프로퍼티를 isolated로 표시하면 해당 actor 상태에 안전하게 접근하고 수정할 수 있다.
• 데이터의 무결성을 유지와 동시성 문제를 해결할 수 있다.

class SendableTestViewModel: ObservableObject {
    @Published var userName: String = ""
    let testActor = SendableTestActor()
    
    func updateStruct() async {
        let libraryInfo = SendableLibraryStruct(name: "kim", bookCount: 19)
        await testActor.updateDataWithStruct(libraryInfo: libraryInfo)
    }
    
    func updateClass() async {
        let libraryInfo = SendableLibraryClass(name: "lee", bookCount: 20)
        await testActor.updateDataWithClass(libraryInfo: libraryInfo)
    }
    
    @MainActor
    func getName() async {
        do {
            self.userName = try await testActor.getNameFromClass()
        } catch {
            
        }
        
    }
}

 

ViewModel에 actor인 SendableTestActor를 사용해서 스레드 간에 안전하게 값을 전달 할 수 있다. updateStruct()와 updateClass는 값을 전달 받아 내부 데이터를 안전하게 수정한다.

 

    func getNameFromClass() async throws -> String {
        try await Task.sleep(until: .now + .seconds(1), clock: .continuous)
        return libraryClass.name
    }

 

actor인 SendableTestActor을 확인해 보면 내부 데이터 중 이름을 반환하는 비동기 함수가 있다. 이를 viewModel에서 전달받아 사용할 수 있다. 

 

    @MainActor
    func getName() async {
        do {
            self.userName = try await testActor.getNameFromClass()
        } catch {
            
        }
    }

 

actor을 사용하면 actor의 state에 안전하게 접근하고 수정하며 값을 가져올 수 있기 때문에 데이터의 무결성을 유지하면서 동시성 문제를 해결 할 수 있다. 

 

 

References

[WWDC21] Use async/await with URLSession을 적용해보자..!

[Swift] async / await & concurrency

https://www.hackingwithswift.com/sixty/5/10/inout-parameters

[SwiftUI] Sendable

 

[Swift] Sendable

+) ChatGPT

이후 공부할 것

Explore structured concurrency in Swift - WWDC21 - Videos - Apple Developer

 

Sendable and @Sendable closures explained with code examples

 

https://pixabay.com/ko/photos/%EC%B9%98%EC%A6%88-%EB%84%A4%EB%8D%9C%EB%9E%80%EB%93%9C-%EC%B9%98%EC%A6%88-%EC%8B%9C%EC%9E%A5-8437668/