Meet Swift Async Algorithms ‐ WWDC 2022

Swift Async Algorithms 소개 (WWDC 2022)

AsyncSequence 복습

Swift는 오픈 소스 패키지 카탈로그가 점점 확장되고 있습니다. Swift Async Algorithms 패키지는 Swift Collections, Swift Algorithms와 함께하는 새로운 패키지입니다. 이 패키지는 AsyncSequence를 사용하여 시간에 따라 값을 처리하는 알고리즘 세트입니다.

AsyncSequence는 비동기적으로 생성되는 값을 설명할 수 있는 프로토콜입니다. 기본적으로 Sequence와 동일하지만 두 가지 핵심 차이점이 있습니다:

1. Iterator의 next 함수가 비동기적이어서 Swift 동시성을 사용하여 값을 전달할 수 있습니다
2. Swift의 throw 효과를 사용하여 잠재적인 실패를 처리할 수 있습니다

"In short, if you know how to use Sequence, you already know how to use AsyncSequence." (요약하면, Sequence 사용법을 알면 이미 AsyncSequence 사용법도 아는 것입니다.)

for-await-in 구문을 사용하여 반복할 수 있습니다. AsyncSequence가 도입되었을 때, map, filter, reduce 등 Sequence에서 기대할 수 있는 거의 모든 도구의 async 버전이 추가되었습니다. Swift Async Algorithms 패키지는 더 고급 알고리즘을 통합하고, Clock과의 상호 운용을 통해 강력한 기능을 제공합니다.

---

메시징 앱 예제

작년에 Swift Algorithms 패키지를 소개하면서 메시징 앱을 만들었습니다. 이 앱을 Swift 동시성으로 마이그레이션할 좋은 기회가 많다고 판단했습니다.

struct Account {
  var messages: AsyncStream
}  

actor AccountManager {
  var primaryAccount: Account
  var secondaryAccount: Account? 
}

protocol MessagePreview {
  func displayPreviews(_ manager: AccountManager) async
}

---

여러 입력 AsyncSequence 결합 알고리즘

Zip

여러 입력 AsyncSequence를 함께 작업하기 위한 알고리즘 패밀리가 있습니다. 이들은 모두 하나의 특성을 공유합니다: 여러 입력 AsyncSequence를 받아 하나의 출력 AsyncSequence를 생성합니다.

Zip 알고리즘은 여러 입력을 받아 각 기반에서 결과의 튜플을 생성하도록 반복합니다. 비동기 Zip 알고리즘은 표준 라이브러리의 Zip 알고리즘과 동일하게 작동하지만, 각 기반을 동시에 반복하고 반복 중 실패가 발생하면 오류를 rethrow합니다.

"The asynchronous Zip algorithm works just like the Zip algorithm in the standard library, but it iterates each of the bases concurrently and rethrows errors if a failure occurs on iterating any of them." (비동기 Zip 알고리즘은 표준 라이브러리의 Zip과 동일하게 작동하지만, 각 기반을 동시에 반복하고 반복 중 실패 시 오류를 rethrow합니다.)

오류 rethrow와 함께 동시 반복을 수행하는 것은 상당히 복잡할 수 있지만, Swift Async Algorithms 패키지가 이 모든 것을 처리해줍니다.

메시징 앱에서 비디오 녹화의 미리보기를 비동기적으로 생성하고, 효율적인 저장 및 전송을 위해 비디오를 여러 크기로 트랜스코딩하는 많은 코드가 있었습니다. Zip을 사용하면 트랜스코딩된 비디오가 서버로 전송될 때 미리보기를 함께 보낼 수 있습니다. Zip은 동시에 실행되므로 트랜스코딩이나 미리보기 중 어느 쪽도 서로를 지연시키지 않습니다.

// upload attachments of videos and previews such that every video has a preview 
// that are created concurrently so that neither blocks each other. 

for try await (vid, preview) in zip(videos, previews) {
  try await upload(vid, preview)
}

Zip 자체는 어느 쪽이 먼저 값을 생성했는지에 대한 선호가 없습니다. 비디오가 먼저 생성될 수도 있고 미리보기가 먼저 생성될 수도 있으며, 어느 쪽이든 완전한 튜플을 보내기 위해 다른 쪽을 await합니다. Zip은 각 측면을 동시에 await하여 값의 튜플을 구성하기 때문에 쌍을 함께 업로드할 수 있습니다.

---

Merge

들어오는 메시지를 AsyncSequence로 모델링하는 것이 합리적이라고 결론지었습니다. AsyncStream을 사용하여 메시지를 처리하기로 했는데, 이는 순서를 유지하고 콜백을 메시지의 AsyncSequence로 변환하기 때문입니다.

여러 계정을 지원해야 하는 요청된 기능이 있었습니다. 각 계정은 들어오는 메시지의 AsyncStream을 생성하지만, 이를 구현할 때 모든 것을 하나의 단일 AsyncSequence로 함께 처리해야 합니다. 이를 위해 AsyncSequence를 병합하는 알고리즘이 필요했습니다.

Swift Async Algorithms 패키지에는 정확히 이를 위한 알고리즘이 있습니다: "Merge"

"It works similarly to Zip in the regards that it concurrently iterates multiple AsyncSequences. But instead of creating paired tuples, it requires the bases to share the same element type and merges the base AsyncSequences into one singular AsyncSequence of those elements." (Merge는 여러 AsyncSequence를 동시에 반복한다는 점에서 Zip과 유사하게 작동합니다. 하지만 쌍으로 된 튜플을 만드는 대신, 기반들이 동일한 요소 타입을 공유해야 하며 기반 AsyncSequence들을 해당 요소의 단일 AsyncSequence로 병합합니다.)

// Display previews of messages from either the primary or secondary account

for try await message in merge(primaryAccount.messages, secondaryAccount.messages) {
  displayPreview(message)
}

Merge는 반복될 때 어느 쪽에서든 먼저 생성된 요소를 가져옵니다. 더 이상 생성될 수 있는 값이 없을 때까지, 즉 모든 기반 AsyncSequence가 iterator에서 nil을 반환할 때까지 반복을 계속합니다. 기반 중 하나라도 오류를 생성하면 다른 반복들은 취소됩니다.

---

Clock API를 활용한 시간 기반 알고리즘

이러한 결합 알고리즘들은 값이 생성될 때 동시에 작동하지만, 때로는 시간 자체와 실제로 상호작용하는 것이 유용합니다. Swift Async Algorithms 패키지는 Swift의 새로운 Clock API를 활용하여 시간과 함께 작동하는 알고리즘 패밀리를 제공합니다.

시간 자체는 정말 복잡한 주제가 될 수 있으며, Swift 5.7에서 이를 안전하고 일관되게 만드는 API 세트가 새로 도입되었습니다: Clock, Instant, Duration.

"The Clock protocol defines two primitives, a way to wake up after a given instant and a way to produce a concept of now." (Clock 프로토콜은 두 가지 기본 요소를 정의합니다: 주어진 시점 이후에 깨어나는 방법과 '지금'의 개념을 생성하는 방법.)

몇 가지 내장 Clock이 있습니다. 더 일반적인 두 가지는 ContinuousClock과 SuspendingClock입니다.

SuspendingClock

// Sleep until a given deadline

let clock = SuspendingClock()
var deadline = clock.now + .seconds(3)
try await clock.sleep(until: deadline)

앱에서 새로운 Clock API를 사용하여 기존 콜백 이벤트를 clock sleep 함수로 마이그레이션하여 마감 시간 후 알림을 해제하는 것을 처리했습니다. 지연하려는 초 수를 구체적으로 나타내는 duration 값을 추가하여 마감 시간을 생성할 수 있었습니다.

SuspendingClock vs ContinuousClock

ContinuousClock은 스톱워치처럼 시간을 측정하는 데 사용할 수 있으며, 측정 대상의 상태와 관계없이 시간이 진행됩니다. 반면 SuspendingClock은 이름이 암시하듯이 기기가 절전 모드에 들어가면 일시 중지됩니다.

Clock에는 작업 실행의 경과 시간을 측정하는 편리한 메서드도 있습니다:

let clock = SuspendingClock()
let elapsed = await clock.measure {
  await someLongRunningWork()
}
//Elapsed time reads 00:05.40

let clock = ContinuousClock()
let elapsed = await clock.measure {
  await someLongRunningWork()
}
//Elapsed time reads 00:19.54

이 두 Clock의 핵심 차이점은 기기가 절전 모드일 때의 동작에서 나옵니다. 오래 실행되는 작업의 경우, 작업이 일시 중지될 수 있지만, 실행을 재개하면 ContinuousClock은 기기가 잠자는 동안에도 진행되었지만, SuspendingClock은 그렇지 않습니다.

"If you need to interact with time in relation to the machine, like for animations, use the SuspendingClock. Measuring tasks in relation to the human in front of the device is better suited for the ContinuousClock." (애니메이션과 같이 기기와 관련하여 시간과 상호작용해야 하는 경우 SuspendingClock을 사용하세요. 기기 앞의 사람과 관련하여 작업을 측정하는 것은 ContinuousClock이 더 적합합니다.)

일반적으로 이 차이점은 애니메이션과 같은 것이 실행 타이밍을 일시 중지하여 예상대로 작동하도록 하는 핵심 세부 사항이 될 수 있습니다. 절대 지속 시간으로 지연해야 하는 경우, 즉 인간에 상대적인 것은 ContinuousClock을 사용하세요.

---

Debounce - 검색 메시지 제어

Swift Async Algorithms 패키지는 이러한 새로운 Clock, Instant, Duration 타입을 사용하여 시간과 관련하여 이벤트가 처리되는 방식에 대한 많은 개념을 다루는 제네릭 알고리즘을 구축합니다.

메시징 앱에서 이벤트에 대한 정밀한 제어를 제공하는 데 정말 유용했습니다. 상호작용을 속도 제한하고 메시지를 효율적으로 버퍼링할 수 있게 해주었습니다. 아마도 시간을 가장 많이 활용한 영역은 메시지 검색이었습니다.

// Control searching messages

class SearchController {
  let searchResults = AsyncChannel()

  func search(_ searchValues: SearchValues) 
    where SearchValues.Element == String 
}

결과 채널을 관리하는 컨트롤러를 만들었습니다. 채널은 검색 작업에서 UI로 검색 결과를 전달합니다. 검색 작업 자체는 시간과 관련하여 몇 가지 특정 특성이 필요했습니다. 서버에서 전송된 메시지 검색을 속도 제한하고 싶었습니다.

Debounce 알고리즘은 반복될 때 다음 값을 방출하기 전에 정적 기간(quiescence period)을 기다립니다. 이벤트가 빠르게 들어올 수 있지만, 값을 처리하기 전에 조용한 기간을 기다리고 싶습니다.

"When user input from a search field is changed rapidly, we don't want the search controller to fire off a search request for each change. Instead, we want to make sure to wait for a quiet period when we're certain typing was likely to be done." (검색 필드의 사용자 입력이 빠르게 변경될 때, 각 변경마다 검색 컨트롤러가 검색 요청을 보내는 것을 원하지 않습니다. 대신, 타이핑이 완료되었을 것이 확실한 조용한 기간을 기다리고 싶습니다.)

let queries = searchValues
   .debounce(for: .milliseconds(300))

for await query in queries {
  let results = try await performSearch(query)
  await channel.send(results)
}

기본적으로 Debounce 알고리즘은 ContinuousClock을 사용합니다. 이 경우, 아무것도 발생하지 않는 동안 지정된 기간을 기다리도록 입력을 debounce할 수 있습니다.

---

Chunked - 메시지 배치 처리

Clock과 Duration은 debounce뿐만 아니라 다른 알고리즘에도 사용됩니다. 정말 유용한 영역 중 하나는 서버로 메시지 배치를 전송하는 것이었습니다.

Swift Algorithms 패키지에는 값을 청크로 나누는 알고리즘 세트가 있습니다. Swift Async Algorithms 패키지는 이러한 알고리즘을 제공하고, Clock 및 Duration과 상호 운용하는 버전 세트도 추가합니다.

"The family of chunking algorithms allow for control over chunks by count, by time, or by content. If an error occurs in any of these, that error is rethrown, so our code is safe when it comes to failures." (청킹 알고리즘 패밀리는 개수, 시간 또는 내용별로 청크를 제어할 수 있게 합니다. 이 중 어느 곳에서든 오류가 발생하면 해당 오류가 rethrow되므로 실패에 대해 코드가 안전합니다.)

let batches = outboundMessages.chunked(
  by: .repeating(every: .milliseconds(500))
)

let encoder = JSONEncoder() 
for await batch in batches {
  let data = try encoder.encode(batch)
  try await postToServer(data) 
}

chunked(by:) API를 사용하여 메시지 청크가 특정 경과 기간에 따라 직렬화되어 전송되도록 했습니다. 그렇게 하면 서버가 클라이언트로부터 효율적인 패킷을 받습니다. 이 API를 사용하여 500밀리초마다 메시지 배치를 구축할 수 있었습니다. 그래서 누군가가 정말 흥분해서 정말 빠르게 타이핑하면 서버로 전송되는 요청이 그룹화됩니다.

---

Collection 초기화 - AsyncSequence에서 컬렉션으로

컬렉션과 시퀀스를 다룰 때, 요소를 지연 처리(lazily process)하는 것이 유용하고 성능이 좋은 경우가 많습니다. AsyncSequence는 Swift 표준 라이브러리의 lazy 알고리즘이 작동하는 방식과 매우 유사하게 작동합니다. 하지만 그러한 lazy 알고리즘처럼 컬렉션 세계로 다시 이동해야 하는 경우가 종종 있습니다.

"The Swift Async Algorithms package offers a set of initializers for constructing collections using AsyncSequence. These let you build up dictionaries, sets, or arrays with input AsyncSequences that are known to be finite." (Swift Async Algorithms 패키지는 AsyncSequence를 사용하여 컬렉션을 구성하기 위한 초기화기 세트를 제공합니다. 이를 통해 유한한 것으로 알려진 입력 AsyncSequence로 딕셔너리, 셋 또는 배열을 구축할 수 있습니다.)

// Create a message with awaiting attachments to be encoded
init(_ attachments: Attachments) async rethrows {
  self.attachments = try await Array(attachments)
}

컬렉션 초기화기를 통해 메시지 초기화에 변환을 바로 구축하고 데이터 타입을 Array로 유지할 수 있었습니다. Swift 동시성을 사용하도록 업데이트할 수 있는 많은 기능이 있었기 때문에 정말 유용했습니다. 기존 데이터 구조를 유지함으로써 앱의 일부를 점진적으로, 합리적인 곳에서 마이그레이션할 수 있습니다.

---

Swift Async Algorithms 패키지 요약

지금까지 Swift Async Algorithms 패키지의 몇 가지 하이라이트만 살펴보았습니다. 오늘 다룬 것보다 훨씬 더 많은 것이 있습니다:

• 여러 AsyncSequence 결합 (Zip, Merge)
• 시간에 의한 속도 제한 (Debounce)
• 청크로 나누기 (Chunked)

하지만 이것들은 앱에서 광범위하게 사용한 하이라이트일 뿐입니다. 이 패키지에는 훨씬 더 많은 것이 있습니다:

• 버퍼링
• 리듀싱
• 조인
• 간헐적으로 값 주입
• 그리고 더 많은 것들

Swift Async Algorithms 패키지는 시간에 따른 것들을 다루는 알고리즘 세트를 가져와 앱에서 도움이 될 수 있는 광범위한 고급 기능으로 확장합니다.

이 패키지는 오픈 소스로 개발되고 있습니다.

---

💡 핵심 요약

Q: Zip과 Merge의 차이점은 무엇인가요?

구분	Zip	Merge
출력	튜플 (A, B)	단일 요소
요소 타입	다른 타입 가능	동일 타입 필수
완료 조건	어느 한쪽이 끝나면 완료	모든 쪽이 끝나야 완료
사용 사례	짝지어야 하는 데이터	여러 소스 통합

핵심 요약:

• 개념 요약: Zip은 여러 AsyncSequence에서 값을 동시에 가져와 튜플로 짝짓고, Merge는 여러 AsyncSequence를 하나의 스트림으로 합칩니다
• 핵심 키워드: concurrent iteration / tuple / same element type / rethrows
• 예시 코드:

// Zip - 비디오와 미리보기를 짝지어 업로드
for try await (vid, preview) in zip(videos, previews) {
  try await upload(vid, preview)
}

// Merge - 여러 계정의 메시지를 하나로 통합
for try await message in merge(account1.messages, account2.messages) {
  displayPreview(message)
}

• 면접 포인트: Zip은 "모든 소스에서 값이 준비될 때까지 대기"하고, Merge는 "먼저 준비된 값을 즉시 전달"한다는 차이를 설명할 수 있어야 함

---

Q: SuspendingClock과 ContinuousClock의 차이점은 무엇인가요?

핵심 요약:

• 개념 요약: SuspendingClock은 기기 절전 시 일시 중지되고, ContinuousClock은 절전과 관계없이 계속 진행
• 핵심 키워드: machine sleep / animation / absolute duration / human-relative time
• 예시 코드:

// 애니메이션용 - 기기 절전 시 일시 중지
let suspending = SuspendingClock()
try await suspending.sleep(until: suspending.now + .seconds(3))

// 사용자 대기 시간 측정용 - 절대 시간
let continuous = ContinuousClock()
let elapsed = await continuous.measure { await longTask() }

• 면접 포인트: 애니메이션에는 SuspendingClock, 사용자 경험 측정에는 ContinuousClock 사용 이유를 설명할 수 있어야 함

---

Q: Debounce와 Throttle의 차이점은 무엇인가요?

핵심 요약:

• 개념 요약: Debounce는 "조용한 기간" 후에 값을 방출하고, Throttle은 일정 간격으로 최신 값을 방출
• 핵심 키워드: quiescence period / rate limiting / search input / ContinuousClock
• 예시 코드:

// 300ms 동안 입력이 없으면 검색 실행
let queries = searchValues.debounce(for: .milliseconds(300))
for await query in queries {
  let results = try await performSearch(query)
}

• 면접 포인트: 검색 입력에 Debounce를 사용하는 이유(타이핑 완료 대기)와 스크롤 이벤트에 Throttle을 사용하는 이유(일정 간격 처리)를 구분해서 설명할 수 있어야 함

---

Q: Chunked 알고리즘은 언제 사용하나요?

핵심 요약:

• 개념 요약: 연속적인 이벤트 스트림을 배치로 그룹화하여 효율적으로 처리
• 핵심 키워드: batching / time-based chunking / count-based chunking / efficient network requests
• 예시 코드:

// 500ms마다 메시지 배치 전송
let batches = outboundMessages.chunked(
  by: .repeating(every: .milliseconds(500))
)
for await batch in batches {
  let data = try encoder.encode(batch)
  try await postToServer(data)
}

• 면접 포인트: 개별 요청 대신 배치 처리로 네트워크 효율성을 높이는 방법과, 시간/개수/내용 기준 청킹의 사용 사례를 설명할 수 있어야 함

---

Q: AsyncSequence를 Collection으로 변환하는 방법은?

핵심 요약:

• 개념 요약: Swift Async Algorithms 패키지의 Collection 초기화기를 사용하여 유한한 AsyncSequence를 Array, Set, Dictionary로 변환
• 핵심 키워드: finite AsyncSequence / incremental migration / lazy to eager / rethrows
• 예시 코드:

init(_ attachments: Attachments) async rethrows {
  self.attachments = try await Array(attachments)
}

• 면접 포인트: AsyncSequence가 유한해야 하는 이유(무한 시퀀스는 배열로 변환 불가)와 점진적 마이그레이션 전략에서의 활용을 설명할 수 있어야 함

---

📝 새롭게 알게 된 정보

1. AsyncSequence → Collection 변환 시 "유한성" 필수

Array(asyncSequence)는 모든 요소가 끝날 때까지 기다려야 배열을 생성할 수 있습니다.

// Array 초기화기의 내부 동작 (개념적)
extension Array {
    init(_ sequence: S) async rethrows where S.Element == Element {
        var result: [Element] = []
        for try await element in sequence {  // ← 모든 요소를 하나씩 기다림
            result.append(element)
        }
        self = result  // ← 모든 요소가 끝나야 여기에 도달
    }
}

무한 시퀀스의 문제:

// ❌ 무한 AsyncSequence 예시
let infiniteStream = AsyncStream { continuation in
    var n = 0
    Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { _ in
        continuation.yield(n)  // 1초마다 계속 값 생성
        n += 1
    }
    // continuation.finish()가 절대 호출되지 않음!
}

// 이 코드는 영원히 완료되지 않음
let array = try await Array(infiniteStream)  // 🔴 무한 대기 + 메모리 무한 증가
print(array)  // 절대 실행 안됨

유한 시퀀스의 정상 동작:

// ✅ 유한 AsyncSequence 예시
let finiteStream = AsyncStream { continuation in
    for i in 0..<5 {
        continuation.yield(i)
    }
    continuation.finish()  // 종료 신호!
}

let array = try await Array(finiteStream)  // ✅ 정상 완료
print(array)  // [0, 1, 2, 3, 4]

핵심: continuation.finish() 호출로 종료를 명시하는 유한한 AsyncSequence만 Collection으로 변환 가능합니다. 무한 AsyncSequence는 절대 끝나지 않으므로 변환이 완료되지 않고, 메모리도 무한히 증가합니다.

---

2. Collection 초기화기를 통한 점진적 마이그레이션

Swift Async Algorithms 패키지는 Array, Set, Dictionary 초기화기를 제공합니다. 이를 통해 기존 데이터 구조를 유지하면서 데이터 로딩 부분만 AsyncSequence로 전환할 수 있습니다.

점진적 마이그레이션 예시:

// 기존 코드 - 동기 방식
class MessageStore {
    var messages: [Message] = []
    
    func loadMessages() {
        // 동기적으로 메시지 로드
    }
}

// 마이그레이션 후 - 비동기 데이터 소스, 동기 저장
class MessageStore {
    var messages: [Message] = []  // ← 기존 Array 타입 유지!
    
    func loadMessages() async throws {
        // 비동기 스트림에서 데이터를 가져와 Array로 변환
        let messageStream = fetchMessagesFromServer()  // AsyncSequence 반환
        self.messages = try await Array(messageStream)  // ← Array로 변환
    }
}

다양한 Collection 변환:

// Set 변환 (중복 제거)
func collectUniqueTags(_ tagStream: S) async throws -> Set
    where S.Element == String {
    return try await Set(tagStream)
}

// Dictionary 변환
func buildUserCache(_ userStream: S) async throws -> [UserID: User]
    where S.Element == User {
    return try await Dictionary(
        uniqueKeysWithValues: userStream.map { ($0.id, $0) }
    )
}

핵심: UI 레이어나 다른 부분은 변경 없이 데이터 로딩 부분만 비동기로 전환하여 앱 전체를 한 번에 바꾸지 않고 점진적으로 Swift Concurrency를 도입할 수 있습니다.

---

3. Chunked 알고리즘의 세 가지 그룹화 방식

Chunked는 연속적인 이벤트 스트림을 **묶음(batch)**으로 그룹화하는 알고리즘입니다. 세 가지 청킹 방식을 지원합니다:

방식	API	설명
시간 기준	chunked(by: .repeating(every:))	일정 시간마다 묶음 생성
개수 기준	chunked(by: .count(_:))	특정 개수만큼 묶기
내용 기준	chunked(on:)	조건 변경 시 묶음 분리

시간 기준 청킹 예시:

// 500ms마다 메시지를 모아서 서버로 전송
let batches = outboundMessages.chunked(
    by: .repeating(every: .milliseconds(500))
)

for await batch in batches {
    // batch: [Message] - 500ms 동안 모인 메시지들
    let data = try encoder.encode(batch)
    try await postToServer(data)
}

시간 흐름 →
|------ 500ms ------|------ 500ms ------|
   msg1, msg2, msg3      msg4, msg5
        ↓                    ↓
   [msg1, msg2, msg3]   [msg4, msg5]

왜 Chunking이 필요한가?

// ❌ 비효율적: 메시지마다 네트워크 요청
for await message in messages {
    try await postToServer(message)  // 100개 메시지 = 100번 요청
}

// ✅ 효율적: 배치로 묶어서 요청
for await batch in messages.chunked(by: .repeating(every: .milliseconds(500))) {
    try await postToServer(batch)  // 100개 메시지 = 수 번의 요청
}

핵심: 네트워크 요청 횟수를 줄이거나 효율적인 배치 처리에 활용되며, 시간/개수/내용 기준 세 가지 방식 중 상황에 맞게 선택할 수 있습니다.

---

참고 자료

• Swift Async Algorithms GitHub
• Swift Evolution - AsyncSequence
• Apple Developer Documentation - Clock
• WWDC 2022 - Meet Swift Async Algorithms