[Swift Language Guide] Concurrency (async/await, task, actor)

https://docs.swift.org/swift-book/documentation/the-swift-programming-language/concurrency/
위 공식문서를 번역한 내용입니다.

동시성 : 비동기 작업 수행하기.

병렬(parallel) 또는 비동기(asynchronous) 코드는 복잡도 증가라는 비용을 가져온다.
Swift에서는 컴파일 타임 검사가 가능한 방식으로 개발자의 의도를 표현할 수 있다 - 예를 들어 actor를 사용해 mutable state에 안전하게 접근할 수 있다.
Swift는 언어 수준에서 비동기 코드의 문제를 컴파일 타임에 잡을 수 있도록 돕는다.

Swift의 동시성 모델은 쓰레드 위에 구축되지만, 쓰레드와 직접 상호작용하지는 않는다.

completion handler를 사용하는 기존 코드

listPhotos(inGallery: "Summer Vacation") { photoNames in
    let sortedNames = photoNames.sorted()
    let name = sortedNames[0]
    downloadPhoto(named: name) { photo in
        show(photo)
    }
}

클로저를 중첩해 사용하므로 가독성이 안 좋아지고, 복잡해진다.

비동기 함수의 정의 및 호출

비동기 함수/메서드 : 실행 중 일시정지할 수 있는 특수한 종류의 함수/메서드를 의미함.
보통의 함수(동기식) 은 완료될 때까지 실행되거나, 오류가 발생하거나, 반환되지 않는 식으로 동작한다. 비동기 함수도 이런 식으로 동작하지만, 가장 큰 차이는 어떤 작업을 기다리는 동안 일시정지를 할 수 있다는 점이다.

비동기 함수를 정의하기 위해서는 파라미터 선언과 -> 사이에 async 키워드를 작성한다.
에러를 던지는 비동기 함수는 async throws 순으로 작성한다.

func listPhotos(inGallery name: String) async -> [String] {
    let result = // ... some asynchronous networking code ...
    return result
}

비동기 함수를 호출하면, 메서드가 반환될 때까지 실행이 중지된다.
일시정지가 발생할 수 있는 부분을 호출할 때에는 앞에 await 키워드를 작성한다. (에러가 발생할 수 있는 함수를 호출할 때, try 를 작성하는 것과 비슷하다)

실행 흐름이 일시정지하는 경우는 오직 다른 비동기 메서드를 호출했을 때이다 - 일시정지는 절대 암묵적이거나 선점적이지 않다. 즉 모든 가능한 일시정지 지점이 await 로 표시된다.

예를 들어, 아래 코드는 갤러리의 모든 사진의 이름을 가져온 다음 첫 번째 사진을 보여준다:

let photoNames = await listPhotos(inGallery: "Summer Vacation")
let sortedNames = photoNames.sorted()
let name = sortedNames[0]
let photo = await downloadPhoto(named: name)
show(photo)

• listPhotos(inGallery:) 와 downloadPhoto(named:) 함수는 모두 네트워크 요청을 필요로 하므로, 작업 완료에 상대적으로 긴 시간이 소요된다.
• 두 함수를 async 를 통해 비동기로 만들면, 사진이 준비되기를 기다리는 동안 앱의 나머지 코드들이 동작하도록 할 수 있다.

위 코드의 실행 순서는 다음과 같다:

1. 첫 번쨰 줄부터 코드가 실행되어, 첫 번쨰 await 까지 실행된다. 그것은 listPhotos(inGallery:) 함수를 호출하고, 그 함수가 반환되기를 기다리는 동안 실행을 일시정지한다.
2. 이 코드의 실행이 중지된 동안, 같은 프로그램에 있는 다른 몇몇 동시성 코드가 실행된다.
   1. 예를 들어, 오래 걸리는 백그라운드 작업이 새 포토 갤러리의 목록을 계속 업데이트할 것이다.
   2. 그 코드는 await 로 표시된 다음 일시정지 지점에 도달할 때까지, 또는 완료될 떄까지 실행될 것이다.
3. listPhotos(inGallery:) 가 반환된 후, 이 코드는 그 지점부터 실행을 계속할 것이다. photoNames 에 반환된 값을 할당할 것이다.
4. sortedNames 와 name 에 정의된 코드는 일반적인 동기 코드이다. 따라서 어떤 일시정지도 발생하지 않는다.
5. 다음 await 가 downloadPhoto(named:) 함수 호출에 표시되어 있다. 이 코드는 이 함수가 반환될 때까지 실행을 또다시 일시정지할 것이며, 다른 동시성 코드가 실행될 기회를 줄 것이다.
6. downloadPhoto(named:) 가 반환된 후에, 그 반환값은 photo 에 할당되며 show(_:) 가 호출될 때에 아규먼트로서 전달될 것이다.

코드 내에서 일시정지가 발생할 수 있는 지점은 await 로 표시되어, 비동기 함수 또는 메서드가 반환되기를 기다리는 동안 현재 코드 조각이 실행을 중지시킬 수 있음을 나타냅니다. 이것은 또한 쓰레드 양보(yielding the thread) 라고도 불리는데, 그 이유는 Swift가 뒷단에서 현재 쓰레드의 코드 실행을 중지시키고 그 스레드의 다른 코드를 대신 실행시키기 때문입니다.

await 로 표시된 코드는 실행을 일시정지할 수 있어야 하므로, 프로그램의 특정 위치에서만 비동기 함수를 호출할 수 있습니다 :

• 비동기 함수/메서드/프로퍼티의 body에서
• @main 으로 표시된 구조체, 클래스, 열거형의 static main() 함수에서
• Unstructured Concurrency의 내용과 같이, 구조화되지 않은 child task에서

중단될 수 있는 지점 사이의 코드는, 다른 동시성 코드의 방해 없이 순차적으로(sequentially) 실행된다. 예를 들어, 아래 코드는 한 갤러리에서 다른 갤러리로 사진을 옮긴다.

let firstPhoto = await listPhotos(inGallery: "Summer Vacation")[0]
add(firstPhoto, toGallery: "Road Trip")
// At this point, firstPhoto is temporarily in both galleries.
remove(firstPhoto, fromGallery: "Summer Vacation")

add(_:toGallery:) 호출과 remove(_:fromGallery:) 호출 사이에 다른 코드를 실행할 방법이 없다. 그 시간 동안, 첫 번째 사진이 두 갤러리 모두에 나타나 일시적으로 앱의 불변성(invariant) 중 하나를 위배한다. 더 이상의 await 가 추가되어선 안 됨을 명확히 하기 위해, 해당 코드는 동기 함수로 리팩토링할 수 있다:

func move(_ photoName: String, from source: String, to destination: String) {
    add(photoName, toGallery: destination)
    remove(photoName, fromGallery: source)
}
// ...
let firstPhoto = await listPhotos(inGallery: "Summer Vacation")[0]
move(firstPhoto, from: "Summer Vacation", to: "Road Trip")

위의 예시에서, move(_:from:to:) 함수가 동기 함수이기 때문에, 당신은 어떤 일시정지도 발생하지 않을 것임을 확신할 수 있다. 나중에 만약 이 함수에 일시정지될 수 있는 동시성 코드를 추가하고 싶다면, 버그가 발생하는 대신 컴파일 타임 에러를 받을 수 있다.

참고

Task.sleep(until:tolerance:clock:) 메서드는 동시성이 어떻게 동작하는지 배우기 위한 간단한 코드를 작성할 때 유용하다. 이 메서드는 아무 것도 하지 않지만, 반환되기 전에 최소한 주어진 시간만큼 기다린다. 아래는 위의 listPhotos(inGallery:) 함수에 sleep(until:tolerance:clock:) 를 사용하여 네트워크 작업을 기다리는 것을 흉내낸 것이다 :

func listPhotos(inGallery name: String) async throws -> [String] {
    try await Task.sleep(until: .now + .seconds(2), clock: .continuous)
    return ["IMG001", "IMG99", "IMG0404"]
}

비동기 시퀀스

이전 섹션의 listPhotos(inGallery:) 함수는, 배열의 모든 요소가 준비된 이후에 비동기적으로 전체 배열을 한 번에 반환한다.
다른 방법으로, 비동기 시퀀스(asynchronous sequence) 를 사용해 한 번에 컬렉션의 한 요소를 기다릴 수 있다. 아래는 비동기 시퀀스를 반복(iterating over)하는 모습이다:

import Foundation

let handle = FileHandle.standardInput
for try await line in handle.bytes.lines {
    print(line)
}

위의 예시는 일반적인 for-in 반복문 대신에, for 를 await 과 함께 작성했다. 비동기 함수 또는 메서드를 호출할 때와 같이, await 를 작성하는 것은 일시중단이 발생할 수 있는 지점을 나타낸다. for-await-in 반복문은 다음 요소가 준비되는 것을 기다릴 때, 각 반복의 시작 시점의 실행을 중단할 수 있다.

Sequence 프로토콜을 채택함으로써 for-in 반복문에서 사용자 정의 타입을 사용할 수 있는 것처럼, AsyncSequence 프로토콜을 채택함으로써 for-await-in 반복문에서 사용자 정의 타입을 사용할 수 있다.

병렬로 비동기 함수 호출하기

await 로 선언된 비동기 함수를 호출하는 것은 한 번에 한 조각의 코드만 실행한다. 비동기 코드가 실행되는 동안, 호출자는 다음 코드 줄로 이동하기 전에 그 코드가 완료되기를 기다립니다.

예를 들어, 갤러리에서 처음부터 3개의 사진을 가져오기 위해, 아래와 같이 downloadPhoto(named:) 함수를 await 로 세 번 호출할 수 있습니다:

let firstPhoto = await downloadPhoto(named: photoNames[0])
let secondPhoto = await downloadPhoto(named: photoNames[1])
let thirdPhoto = await downloadPhoto(named: photoNames[2])

let photos = [firstPhoto, secondPhoto, thirdPhoto]
show(photos)

이 방법은 중요한 약점이 있습니다: 다운로드가 비동기이고 그 진행 동안 다른 작업이 발생할 수 있도록 되어 있지만, 한 번에 오직 하나의 downloadPhoto(named:) 만이 실행됩니다. 각각의 사진은 다음 것의 다운로드가 시작되기 전에 완전히 다운로드됩니다. 하지만, 이러한 작업을 기다릴 필요가 없습니다 - 각각의 사진은 독립적으로 다운로드될 수 있고, 심지어 동시에도 가능합니다.

비동기 함수를 호출하고 주변의 코드와 병렬로 실행되도록 하려면, 상수를 정의할 때 let 앞에 async 를 작성한 다음, 그 상수를 사용할 때마다 await 를 작성합니다.

async let firstPhoto = downloadPhoto(named: photoNames[0])
async let secondPhoto = downloadPhoto(named: photoNames[1])
async let thirdPhoto = downloadPhoto(named: photoNames[2])

let photos = await [firstPhoto, secondPhoto, thirdPhoto]
show(photos)

이 예시에서는, 3개의 downloadPhoto(named:) 호출이 모두 앞의 작업이 끝나는 것을 기다리지 않고 시작됩니다. 만약 충분한 시스템 리소스를 사용할 수 있다면, 이 작업들은 동시에 실행됩니다. 이 함수 호출 중 어떤 것도 await 로 표시되지 않았습니다. 왜냐하면, 코드가 함수의 결과를 기다리기 위해 일시중단되지 않기 때문입니다. 대신, photos 가 정의된 줄까지 실행이 계속됩니다. 이 줄에서는 프로그램이 비동기 호출들의 결과를 필요로 하므로, 세 개의 사진이 다운로드가 다 될 때까지 실행을 일시정지하기 위해 await 를 작성합니다.

이러한 두 가지 접근법의 차이는 이렇게 생각할 수 있습니다:

• await 로 비동기 함수를 호출하는 경우는, 이후의 코드들이 그 함수의 결과에 의존하고 있을 때입니다. 이렇게 하면 순차적으로 수행되는 작업이 생성됩니다.
• async-let 으로 비동기 함수를 호출하는 경우는, 이후 코드에서 그 결과를 필요로 하지 않을 때 입니다. 이렇게 하면 병렬로 실행되는 작업이 생성됩니다.
• await 와 async-let 은 모두 자신이 일시정지되는 동안 다른 코드가 실행되는 것을 허락합니다.
• 두 경우 모두, 일시정지가 발생할 수 있는 지점을 await 로 표시함으로써 실행이 중지될 수 있고, 필요한 경우 비동기 함수가 반환될 때까지 중지될 수 있음을 나타내야 합니다.

당신은 이 두 방법을 같은 코드에 함께 섞어서 사용할 수도 있습니다.

Tasks와 Task Groups

Task는 당신의 프로그램의 일부로 비동기적으로 실행할 수 있는 작업단위를 의미합니다. 모든 비동기 코드는 어떤 task의 일부로서 실행됩니다.
이전 섹션에서 설명한 async-let 문법의 경우, 당신에게 child task를 만들어 줍니다. 당신은 또한 task group을 만들고 거기에 자식task들을 추가할 수 있습니다. 이것은 우선 순위와 취소에 대한 더 많은 제어를 가능하게 하며, 동적인 숫자의 task들을 만들 수 있게 해 줍니다.
task들은 계층으로 정리됩니다. task group의 각각의 task는 같은 부모task를 가지며, 각각의 task는 자식task들을 가질 수 있습니다. task들과 task group들 사이의 명시적인 관계로 인해, 이러한 접근방식을 구조화된 동시성(structured concurrency) 이라고 합니다. 당신이 정확성에 대한 약간의 책임을 갖긴 하지만, task들 사이의 명시적인 parent-child 관계 덕분에 Swift가 취소 전파(propagating cancellation)와 같은 몇몇 동작을 당신을 위해 해줄 수 있게 됩니다. 또한 Swift가 컴파일 타임에 몇몇 에러들을 감지할 수 있게 됩니다.

await withTaskGroup(of: Data.self) { taskGroup in
    let photoNames = await listPhotos(inGallery: "Summer Vacation")
    for name in photoNames {
        taskGroup.addTask { await downloadPhoto(named: name) }
    }
}

task group에 대한 더 자세한 정보는 TaskGroup 문서를 참조하십시오.

구조화되지 않은 동시성 (Unstructured Concurrency)

위 섹션에 설명된 동시성에 대한 구조화된 접근에 더해, Swift는 구조화되지 않은 동시성 또한 지원합니다. task group에 속한 task와 달리, unstructured task 는 부모 task가 없습니다. 당신의 프로그램에 필요한 어떤 방식으로든 unstructured task를 관리하는 완전한 유연성을 가질 수 있습니다. 하지만 그 정확성에 대한 완전한 책임 또한 가지게 됩니다.
현재 actor에서 실행되는 unstructured task를 만들기 위해서는, Task.init(priority:operation:) 이니셜라이저를 호출하십시오. 현재 actor에 포함되지 않는 unstructured task(보통 detached task 라고 특정해 부릅니다)를 만들기 위해서는, Task.detached(priority:operation:) 클래스 메서드를 호출하십시오. 이 두 작업은 모두 당신이 상호작용(결과를 기다리거나 취소하는 등)할 수 있는 task를 반환합니다.

let newPhoto = // ... some photo data ...
let handle = Task {
    return await add(newPhoto, toGalleryNamed: "Spring Adventures")
}
let result = await handle.value

detached task의 관리에 대한 더 많은 정보는 Task 를 참조하십시오.

Task 취소 (Task Cancellation)

Swift 동시성은 협조적인 취소 모델을 사용합니다. 각각의 task는 실행에 있어 적절한 시점에서 취소되었는지 여부를 확인하고, 적절한 방식으로 취소에 응답합니다. 당신이 하고 있는 작업에 따라, 이것은 보통 아래의 것들 중 하나를 의미합니다:

• CancellationError 와 같은 에러 던지기
• nil 또는 빈 컬렉션 반환하기
• 부분적으로 완료된 work 반환하기

취소를 확인하기 위해, task가 취소되었을 때 CancellationError 를 던지는 Task.checkCancellation() 을 호출하거나, 혹은 Task.isCancelled의 값을 확인해 당신의 코드의 취소를 처리하십시오. 예를 들어, 갤러리로부터 사진을 다운로드하는 작업은 부분적인 다운로드를 삭제하고 네트워크 연결을 종료해야 할 수 있습니다.
취소를 수동으로 전파하려면 Task.cancel() 을 호출하십시오.

Actors

당신의 프로그램을 독립된 동시성 조각으로 나누기 위해 task들을 사용할 수 있습니다. task는 서로로부터 독립되어 있으며, 이는 동시에 실행되더라도 안전할 수 있게 합니다. 하지만 가끔은 task들 사이에 어떤 정보를 공유해야 할 필요가 있을 것입니다. Actors는 당신이 동시성 코드 사이에 정보를 안전하게 공유할 수 있도록 해 줍니다.
클래스와 같이, actors도 참조 타입입니다. 따라서 값 타입과 참조 타입을 비교하는 Classes Are Reference Types 의 내용은 actor에도 클래스처럼 동일하게 적용됩니다.
클래스와 다르게, actors는 한 번에 오직 하나의 task만이 mutable한 상태에 접근하도록 허용합니다. 이는 다수의 task들이 actor의 같은 인스턴스와 상호작용하는 경우 더 안전한 코드를 만들어 줍니다.

예를 들어, 여기에 온도를 기록하는 actor가 있습니다:

actor TemperatureLogger {
    let label: String
    var measurements: [Int]
    private(set) var max: Int // 외부에서는 읽기만, 내부에서는 쓰기도 가능

    init(label: String, measurement: Int) {
        self.label = label
        self.measurements = [measurement]
        self.max = measurement
    }
}

actor는 actor 키워드로 소개하며, 그 정의를 중괄호 내에 작성합니다. TemperatureLogger actor는 actor 바깥의 다른 코드가 접근할 수 있는 프로퍼티를 가지며, max 프로퍼티는 오직 actor 내부의 코드만 최대값을 바꿀 수 있도록 제한합니다.
actor의 인스턴스를 생성할 때도 구조체와 클래스와 같은 이니셜라이저 문법을 사용합니다. actor의 프로퍼티나 메서드에 접근할 때, await 키워드를 사용해 일시정지가 일어날 수 있는 지점을 표시합니다. 예를 들어:

let logger = TemperatureLogger(label: "Outdoors", measurement: 25)
print(await logger.max)
// Prints "25"

이 예시에서, logger.max 에 접근하는 것은 일시정지가 일어날 수 있는 지점입니다. 왜냐하면 actor는 자신의 mutable한 상태에 한 번에 오직 하나의 task가 접근하도록 제한하기 때문입니다. 만약 다른 task가 이미 logger와 상호작용하고 있다면, 이 코드는 그 프로퍼티에 접근하기 위해 기다리느라 코드가 일시정지하게 됩니다.

반면, actor의 일부인 코드는 actor의 프로퍼티에 접근할 때 await 키워드를 작성하지 않습니다. 예를 들어, 여기에 TemperatureLogger 를 새로운 온도로 갱신하는 메서드가 있습니다:

extension TemperatureLogger {
    func update(with measurement: Int) {
        measurements.append(measurement)
        if measurement > max {
            max = measurement
        }
    }
}

update(with:) 메서드는 이미 actor 내에서 실행되고 있습니다. 따라서 그것은 max와 같은 프로퍼티에 접근할 때 await 를 붙이지 않습니다. 이 메서드는 또한 왜 actor가 자신의 mutable한 상태와 상호작용할 때 한 번에 오직 하나의 task만을 허용하는지 그 이유를 보여줍니다: actor의 상태에 대한 어떤 변경은 일시적으로 불변성(invariants)을 깨뜨리기 때문입니다. TemperatureLogger actor는 온도의 리스트와 최고 온도를 계속 추적하고 있으며, 새로운 온도가 기록되었을 때 최고 온도를 갱신합니다. 갱신 중간, 즉 새 측정값을 붙인 후와 max 를 갱신하기 전 사이에 TemperatureLogger 는 일시적으로 일관성이 없는 상태가 됩니다. 동시에 같은 인스턴스에 여러 task들이 상호작용하는 것을 막음으로써, 아래와 같은 연속된 사건 발생으로 인한 문제를 막을 수 있습니다:

1. 당신의 코드가 update(with:) 메서드를 호출합니다. 먼저, 그것은 measurement 배열의 값을 바꾸게 됩니다.
2. 당신의 코드가 max 값을 바꾸기 전에, 다른 곳의 코드가 온도 배열과 최대값을 조회합니다.
3. 당신의 코드가 max 값의 갱신을 끝냅니다.

위와 같은 경우, 다른 곳에서 실행중인 코드는 부정확한 정보를 읽게 됩니다. 왜냐하면 actor에 대한 접근이 데이터가 일시적으로 유효하지 않은 시점에 update(with:) 호출 도중에 interleave(교차되어) 일어났기 때문입니다. Swift actor를 사용할 때 이런 문제는 예방될 수 있습니다. 왜냐하면 한 번에 상태값에 대한 하나의 작업만을 허용하고, await가 일시중단 지점을 표시한 지점에서만 코드의 중단이 발생할 수 있기 때문입니다. update(with:) 는 어떤 일시중단 지점도 포함하지 않으므로, 어떤 다른 코드도 업데이트 중간에 데이터에 접근할 수 없습니다.

interleave : 어떤 프로그램의 일부를 다른 프로그램에 끼워 넣는 일. 교차로 배치하는 일?

만약 당신이 actor 바깥에서 이러한 프로퍼티에 접근하려 한다면(마치 클래스의 인스턴스에 접근하듯이), 당신은 컴파일 타임 에러를 만나게 될 것입니다. 예를 들어 :

print(logger.max)  // Error

await 키워드 작성 없이 logger.max 에 접근하는 것은 실패합니다. 왜냐하면 actor의 프로퍼티들은 actor의 독립된 local state의 일부이기 때문입니다. Swift는 오직 actor 내부의 코드만 actor의 local state에 접근할 수 있음을 보장합니다. 이러한 보장은 actor 격리(actor isolation) 라고 합니다.

Sendable Types

task와 actor는 당신의 프로그램이 안전하게 동시적으로 실행될 수 있도록 나누는 것을 돕습니다. task나 actor의 인스턴스 내부에서, mutable한 상태(프로퍼티나 변수 같은)를 포함하는 프로그램의 부분은 동시성 도메인(concurrency domain) 이라고 부릅니다. 어떤 종류의 데이터는 동시성 도메인 간에 공유될 수 없습니다. 그 이유는 그 데이터가 mutable한 상태를 포함하지만 중복 접근(overlapping access)으로부터 보호하지 않기 때문입니다.
하나의 동시성 도메인으로부터 다른 도메인으로 공유될 수 있는 타입은 sendable type 이라고 알려져 있습니다. 예를 들어, 그것은 actor 메서드를 호출하거나 task의 결과로서 반환될 때 아규먼트처럼 전달될 수 있습니다. 이 챕터 이전의 예시들은 sendability에 대해 이야기하지 않았습니다. 그 이유는 그 예시들이 동시성 도메인 간에 전달 및 공유되어도 안전한 데이터인 간단한 값 타입만을 사용했기 때문입니다. 반대로, 어떤 타입들은 동시성 도메인 사이에 전달되기에 안전하지 않습니다. 예를 들어, mutable한 프로퍼티를 포함하며 그 프로퍼티에 대한 접근을 직렬화(serialize)하지 않는 클래스는, 당신이 그 클래스의 인스턴스를 서로 다른 task간에 전달할 때 예측할 수 없고 부정확한 결과를 낳을 수 있습니다.
sendable한 타입으로 표시하기 위해서는 Sendable 프로토콜을 채택해 선언합니다. 이 프로토콜은 어떤 코드도 요구하지 않지만, Swift가 강제하는 의미적 요구사항(semantic requirements) 이 있습니다. 일반적으로, sendable한 타입이 되는 방법에는 세 가지가 존재합니다:

• 타입이 값 타입이며, 그것의 mutable한 상태가 다른 sendable한 테이터로부터 만들어짐 - 예를 들어, 구조체가 저장 프로퍼티들로 구성되어 있는데, 그 저장프로퍼티들이 sendable한 경우. 또는 열거형의 연관값들이 sendable한 경우.
• 타입이 어떤 mutable한 상태도 갖지 않으며, 그것의 immutable한 상태가 다른 sendable한 값으로 구성된 경우 - 예를 들어, 구조체나 클래스가 오직 읽기 전용(read-only) 프로퍼티만 가지고 있는 경우.
• 타입이 그것의 mutable한 상태의 안전성을 보장하는 코드를 가진 경우. 예를 들어 @MainActor 로 표시된 클래스나, 특정 스레드나 큐의 프로퍼티에 대한 접근을 직렬화하는 클래스

의미적 요구사항에 대한 더 자세한 내용은 Sendable 프로토콜을 참조하십시오.

어떤 타입은 항상 sendable합니다. 예를 들어 sendable한 프로퍼티만 갖는 구조체나, sendable한 연관값만 갖는 열거형의 경우입니다. 예를 들어:

struct TemperatureReading: Sendable {
    var measurement: Int
}

extension TemperatureLogger {
    func addReading(from reading: TemperatureReading) {
        measurements.append(reading.measurement)
    }
}

let logger = TemperatureLogger(label: "Tea kettle", measurement: 85)
let reading = TemperatureReading(measurement: 45)
await logger.addReading(from: reading)

TemperatureReading 은 sendable한 프로퍼티만 갖는 구조체이고, public 이나 @usableFromInline으로 표시되지 않았기 때문에, 이것은 암묵적으로 sendable합니다. 다음은 암묵적으로 Sendable 프로토콜 채택이 준수된 구조체의 버전입니다:

struct TemperatureReading {
    var measurement: Int
}