Swift Async/Await 詳細解説：実装メカニズムからベストプラクティスまで

flowchart TD
    A[async 関数呼出] --> B[Continuation の作成]
    B --> C[現在のタスクをサスペンド]
    C --> D[実行コンテキストを保存]
    D --> E[非同期操作の完了を待機]
    E --> F[実行を再開]
    F --> G[結果を返す]

    H[Task 作成] --> I[タスクツリー構造]
    I --> J[親タスクが子タスクを管理]
    J --> K[自動キャンセル伝播]
    K --> L[リソース自動クリーンアップ]

// ソースコード
func fetchData() async throws -> Data {
    let url = URL(string: "https://api.example.com/data")!
    let (data, _) = try await URLSession.shared.data(from: url)
    return data
}

// コンパイラ変換後の擬似コード（簡略版）
func fetchData() -> (Data?, Error?) -> Void {
    return { continuation in
        let url = URL(string: "https://api.example.com/data")!
        URLSession.shared.dataTask(with: url) { data, response, error in
            if let error = error {
                continuation(nil, error)
            } else {
                continuation(data, nil)
            }
        }.resume()
    }
}

// タスク優先度
Task(priority: .userInitiated) {
    await fetchData()
}

// タスクグループ
await withTaskGroup(of: Data.self) { group in
    for url in urls {
        group.addTask {
            try await fetchData(from: url)
        }
    }
}

graph TB
    A[Swift Concurrency Runtime] --> B[Cooperative Thread Pool]
    B --> C[スレッド 1]
    B --> D[スレッド 2]
    B --> E[スレッド N]

    F[Task] --> G[優先度キュー]
    G --> H[高優先度タスク]
    G --> I[通常優先度タスク]
    G --> J[バックグラウンドタスク]

    H --> B
    I --> B
    J --> B

actor BankAccount {
    private var balance: Double = 0

    func deposit(_ amount: Double) {
        balance += amount
    }

    func withdraw(_ amount: Double) -> Double? {
        guard balance >= amount else { return nil }
        balance -= amount
        return amount
    }

    func getBalance() -> Double {
        return balance
    }
}

// 使用例
let account = BankAccount()
await account.deposit(100.0)
let balance = await account.getBalance()

// 各コールバッククロージャはコンテキストをキャプチャする必要がある
func fetchData(completion: @escaping (Data?, Error?) -> Void) {
    // クロージャのキャプチャ：self, url, その他の変数
    // メモリオーバーヘッド：クロージャオブジェクト + キャプチャ変数
}

// Continuation は必要な状態のみを保存
func fetchData() async throws -> Data {
    // メモリオーバーヘッド：Continuation 構造体（約48バイト）
    // ステートマシン状態（最小化）
}

// テスト：1000件の同時ネットワークリクエスト

// 方式1：従来のコールバック
func testCallbacks() {
    let group = DispatchGroup()
    for _ in 0..<1000 {
        group.enter()
        fetchData { _, _ in
            group.leave()
        }
    }
    group.wait()
}
// 所要時間：~2.5秒
// CPU 使用率：~85%

// 方式2：Async/Await
func testAsyncAwait() async {
    await withTaskGroup(of: Void.self) { group in
        for _ in 0..<1000 {
            group.addTask {
                _ = try? await fetchData()
            }
        }
    }
}
// 所要時間：~1.8秒
// CPU 使用率：~65%

// GCD：多数のスレッドを作成する可能性がある
DispatchQueue.global().async {
    // 各キューが新しいスレッドを作成する可能性がある
    // スレッド作成オーバーヘッド：約8KB のスタックスペース + システムリソース
}

// Async/Await：スレッドプールを使用
Task {
    // 既存のスレッドを再利用
    // スレッドプールサイズ：通常は CPU コア数
}

func loadUserData(userId: String, completion: @escaping (User?, Error?) -> Void) {
    DispatchQueue.global().async {
        // ネットワークリクエスト
        fetchUser(userId: userId) { user, error in
            if let error = error {
                DispatchQueue.main.async {
                    completion(nil, error)
                }
                return
            }

            // ユーザーアバターの取得
            fetchAvatar(userId: userId) { avatar, error in
                if let error = error {
                    DispatchQueue.main.async {
                        completion(user, error)
                    }
                    return
                }

                // ユーザーデータの更新
                user?.avatar = avatar
                DispatchQueue.main.async {
                    completion(user, nil)
                }
            }
        }
    }
}

func loadUserData(userId: String) async throws -> User {
    // ネットワークリクエスト
    let user = try await fetchUser(userId: userId)

    // ユーザーアバターの取得
    let avatar = try await fetchAvatar(userId: userId)

    // ユーザーデータの更新
    user.avatar = avatar

    return user
}

// テストシナリオ：10個の非同期操作を順次実行

// GCD 版
func testGCD() {
    let start = Date()
    var currentTask: (() -> Void)?

    currentTask = {
        fetchData { _, _ in
            if let task = currentTask {
                task()
            } else {
                let duration = Date().timeIntervalSince(start)
                print("GCD: \(duration)秒")
            }
        }
    }

    currentTask?()
}

// Async/Await 版
func testAsyncAwait() async {
    let start = Date()
    for _ in 0..<10 {
        _ = try? await fetchData()
    }
    let duration = Date().timeIntervalSince(start)
    print("Async/Await: \(duration)秒")
}

func complexOperation(completion: @escaping (Result<Data, Error>) -> Void) {
    fetchStep1 { result1 in
        switch result1 {
        case .success(let data1):
            processStep1(data1) { result2 in
                switch result2 {
                case .success(let data2):
                    fetchStep2(data2) { result3 in
                        switch result3 {
                        case .success(let data3):
                            completion(.success(data3))
                        case .failure(let error):
                            completion(.failure(error))
                        }
                    }
                case .failure(let error):
                    completion(.failure(error))
                }
            }
        case .failure(let error):
            completion(.failure(error))
        }
    }
}

func complexOperation() async throws -> Data {
    let data1 = try await fetchStep1()
    let data2 = try await processStep1(data1)
    let data3 = try await fetchStep2(data2)
    return data3
}

class DataLoader {
    private var tasks: [URLSessionDataTask] = []

    func load(url: URL, completion: @escaping (Data?) -> Void) {
        let task = URLSession.shared.dataTask(with: url) { data, _, _ in
            completion(data)
        }
        tasks.append(task)
        task.resume()
    }

    func cancelAll() {
        tasks.forEach { $0.cancel() }
        tasks.removeAll()
    }
}

func load(url: URL) async throws -> Data {
    // キャンセル状態を自動チェック
    try Task.checkCancellation()

    let (data, _) = try await URLSession.shared.data(from: url)
    return data
}

// 使用例
let task = Task {
    let data = try await load(url: url)
    // データ処理
}

// キャンセル
task.cancel() // すべての子タスクに自動伝播

class Counter {
    var count = 0

    func increment() {
        count += 1  // データ競合！
    }
}

let counter = Counter()
DispatchQueue.concurrentPerform(iterations: 1000) { _ in
    counter.increment()  // 複数スレッドが同時に count を変更
}
// 結果：count が < 1000 になる可能性がある（データ競合による更新消失）

actor Counter {
    private var count = 0

    func increment() {
        count += 1  // Actor 内部で直列実行、スレッドセーフ
    }

    func getCount() -> Int {
        return count
    }
}

let counter = Counter()
await withTaskGroup(of: Void.self) { group in
    for _ in 0..<1000 {
        group.addTask {
            await counter.increment()
        }
    }
}
let finalCount = await counter.getCount()
// 結果：finalCount == 1000（正確さ保証）

// Sendable 型は並行コンテキスト間で安全に受け渡し可能
struct User: Sendable {
    let id: String
    let name: String
}

actor UserManager {
    private var users: [User] = []

    func addUser(_ user: User) {
        users.append(user)  // User は Sendable なので安全に受け渡し可能
    }
}

// 非 Sendable 型はコンパイルエラーになる
class NonSendableClass {
    var data: String = ""
}

func test() async {
    let manager = UserManager()
    let nonSendable = NonSendableClass()
    // await manager.addUser(nonSendable)  // コンパイルエラー！
}

// Swift 6 では厳格並行チェックが有効化
// コンパイラが潜在的なデータ競合をすべて検出

class SharedState {
    var value = 0  // 警告：可変状態には保護が必要
}

// 解決策1：Actor を使用
actor SafeSharedState {
    private(set) var value = 0

    func update(_ newValue: Int) {
        value = newValue
    }
}

// 解決策2：ロックを使用（非推奨、Actor を優先）
class LockedSharedState {
    private let lock = NSLock()
    private var _value = 0

    var value: Int {
        lock.lock()
        defer { lock.unlock() }
        return _value
    }

    func update(_ newValue: Int) {
        lock.lock()
        defer { lock.unlock() }
        _value = newValue
    }
}

async function fetchData() {
    const response = await fetch('https://api.example.com/data');
    const data = await response.json();
    return data;
}

func fetchData() async throws -> Data {
    let (data, _) = try await URLSession.shared.data(from: url)
    return data
}

async Task<Data> FetchDataAsync() {
    using var client = new HttpClient();
    var response = await client.GetAsync("https://api.example.com/data");
    return await response.Content.ReadAsStringAsync();
}

func fetchData() async throws -> Data {
    let (data, _) = try await URLSession.shared.data(from: url)
    return data
}

async fn fetch_data() -> Result<Data, Error> {
    let response = reqwest::get("https://api.example.com/data").await?;
    let data = response.json().await?;
    Ok(data)
}

func fetchData() async throws -> Data {
    let (data, _) = try await URLSession.shared.data(from: url)
    return data
}

suspend fun fetchData(): Data {
    val response = httpClient.get("https://api.example.com/data")
    return response.body()
}

func fetchData() async throws -> Data {
    let (data, _) = try await URLSession.shared.data(from: url)
    return data
}

// ❌ 誤り：直列実行
func loadAllData() async throws -> [Data] {
    var results: [Data] = []
    for url in urls {
        let data = try await fetchData(from: url)
        results.append(data)
    }
    return results
}

// ✅ 正しい：並列実行
func loadAllData() async throws -> [Data] {
    try await withThrowingTaskGroup(of: Data.self) { group in
        for url in urls {
            group.addTask {
                try await fetchData(from: url)
            }
        }

        var results: [Data] = []
        for try await data in group {
            results.append(data)
        }
        return results
    }
}

// ❌ 誤り：不要な直列化
func processData() async {
    let data1 = await fetchData1()
    let data2 = await fetchData2()  // 並列にできる
    let data3 = await fetchData3()  // 並列にできる
}

// ✅ 正しい：並列実行
func processData() async {
    async let data1 = fetchData1()
    async let data2 = fetchData2()
    async let data3 = fetchData3()

    let results = await [data1, data2, data3]
}

// ❌ 誤り：共有可変状態
class DataCache {
    var cache: [String: Data] = [:]  // データ競合リスク

    func get(key: String) -> Data? {
        return cache[key]
    }
}

// ✅ 正しい：Actor を使用
actor DataCache {
    private var cache: [String: Data] = [:]

    func get(key: String) -> Data? {
        return cache[key]
    }

    func set(key: String, value: Data) {
        cache[key] = value
    }
}

enum NetworkError: Error {
    case invalidURL
    case noConnection
    case timeout
    case serverError(Int)
}

func fetchData() async throws -> Data {
    guard let url = URL(string: "https://api.example.com/data") else {
        throw NetworkError.invalidURL
    }

    do {
        let (data, response) = try await URLSession.shared.data(from: url)
        if let httpResponse = response as? HTTPURLResponse,
           httpResponse.statusCode >= 400 {
            throw NetworkError.serverError(httpResponse.statusCode)
        }
        return data
    } catch {
        if (error as NSError).code == NSURLErrorNotConnectedToInternet {
            throw NetworkError.noConnection
        }
        throw error
    }
}

func fetchDataWithRetry(maxRetries: Int = 3) async throws -> Data {
    var lastError: Error?

    for attempt in 1...maxRetries {
        do {
            return try await fetchData()
        } catch {
            lastError = error
            if attempt < maxRetries {
                let delay = Double(attempt) * 0.5  // 指数バックオフ
                try await Task.sleep(nanoseconds: UInt64(delay * 1_000_000_000))
                continue
            }
        }
    }

    throw lastError ?? NetworkError.timeout
}

func processFile(at path: String) async throws -> Data {
    let fileHandle = try FileHandle(forReadingFrom: URL(fileURLWithPath: path))
    defer {
        try? fileHandle.close()
    }

    return try await fileHandle.readToEnd()
}

class DataLoader {
    private var tasks: [Task<Void, Never>] = []

    func loadData() {
        let task = Task {
            let data = try? await fetchData()
            // データ処理
        }
        tasks.append(task)
    }

    func cancelAll() {
        tasks.forEach { $0.cancel() }
        tasks.removeAll()
    }

    deinit {
        cancelAll()
    }
}

func fetchData() async throws -> Data {
    let taskID = UUID().uuidString
    print("[\(taskID)] データ取得開始")
    defer {
        print("[\(taskID)] データ取得完了")
    }

    let data = try await URLSession.shared.data(from: url).0
    print("[\(taskID)] データサイズ: \(data.count) バイト")
    return data
}

func measureAsyncOperation<T>(_ operation: () async throws -> T) async rethrows -> (T, TimeInterval) {
    let start = Date()
    let result = try await operation()
    let duration = Date().timeIntervalSince(start)
    return (result, duration)
}

// 使用例
let (data, duration) = try await measureAsyncOperation {
    try await fetchData()
}
print("操作時間: \(duration)秒")