Antigravity × Swift Concurrency 実践ガイド — async/await・Actor・Structured Concurrency でiOSアプリの非同期処理を極める

// ❌ 旧来のコールバックスタイル（読みにくく、エラー処理も複雑）
func fetchUser(id: String, completion: @escaping (Result<User, Error>) -> Void) {
    URLSession.shared.dataTask(with: userURL(id: id)) { data, response, error in
        if let error = error {
            completion(.failure(error))
            return
        }
        guard let data = data else {
            completion(.failure(NetworkError.noData))
            return
        }
        do {
            let user = try JSONDecoder().decode(User.self, from: data)
            completion(.success(user))
        } catch {
            completion(.failure(error))
        }
    }.resume()
}
 
// ✅ async/await スタイル（直感的で読みやすい）
func fetchUser(id: String) async throws -> User {
    let (data, _) = try await URLSession.shared.data(from: userURL(id: id))
    return try JSONDecoder().decode(User.self, from: data)
}

// ユーザー情報と投稿一覧を取得して画面に表示
func loadUserProfile(userId: String) async throws -> UserProfile {
    // 順次実行（依存関係がある場合）
    let user = try await fetchUser(id: userId)
    let posts = try await fetchPosts(authorId: user.id)
    let followers = try await fetchFollowers(userId: user.id)
 
    return UserProfile(user: user, posts: posts, followers: followers)
}

// コールバックAPIをasync/awaitでブリッジ
func fetchLegacyData() async throws -> Data {
    try await withCheckedThrowingContinuation { continuation in
        legacyAPI.fetchData { result in
            continuation.resume(with: result)
        }
    }
}

// ✅ Actorを使ったキャッシュ実装（データ競合が発生しない）
actor ImageCache {
    private var cache: [URL: UIImage] = [:]
 
    func image(for url: URL) -> UIImage? {
        return cache[url]
    }
 
    func store(_ image: UIImage, for url: URL) {
        cache[url] = image
    }
 
    func removeAll() {
        cache.removeAll()
    }
}
 
// 使用側
let cache = ImageCache()
 
// Actor のメソッドはawaitが必要（外部からは非同期アクセス）
func loadImage(from url: URL) async -> UIImage {
    // キャッシュをチェック
    if let cached = await cache.image(for: url) {
        return cached
    }
 
    // ネットワークから取得
    let (data, _) = try! await URLSession.shared.data(from: url)
    let image = UIImage(data: data)!
 
    // キャッシュに保存
    await cache.store(image, for: url)
    return image
}

actor UserRepository {
    private var users: [String: User] = [:]
 
    // Actor isolation: awaitが必要
    func findUser(id: String) -> User? {
        return users[id]
    }
 
    // nonisolated: awaitなしで呼べる（Actorの状態に依存しない）
    nonisolated func validateEmail(_ email: String) -> Bool {
        let emailRegex = #"^[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$"#
        return email.range(of: emailRegex, options: .regularExpression) != nil
    }
}

@MainActor
class ArticleViewModel: ObservableObject {
    @Published var articles: [Article] = []
    @Published var isLoading = false
    @Published var errorMessage: String?
 
    private let repository: ArticleRepository
 
    init(repository: ArticleRepository) {
        self.repository = repository
    }
 
    func loadArticles() async {
        isLoading = true
        errorMessage = nil
 
        do {
            // repository.fetchAll() は非Actorコンテキストで実行される可能性がある
            let fetchedArticles = try await repository.fetchAll()
            // @MainActorのため、このプロパティ更新はメインスレッドで行われる
            articles = fetchedArticles
        } catch {
            errorMessage = error.localizedDescription
        }
 
        isLoading = false
    }
}

// Task の基本的な使い方
struct ContentView: View {
    @State private var imageData: Data?
 
    var body: some View {
        Group {
            if let data = imageData {
                Image(uiImage: UIImage(data: data)!)
            } else {
                ProgressView()
            }
        }
        .task {
            // .task modifier: Viewが表示されたら開始、非表示で自動キャンセル
            do {
                let (data, _) = try await URLSession.shared.data(from: imageURL)
                imageData = data
            } catch {
                print("Error: \(error)")
            }
        }
    }
}

func loadDashboard() async throws -> Dashboard {
    // 3つのAPIを並列実行（順次実行の約3倍速）
    async let userProfile = fetchUserProfile()
    async let recentArticles = fetchRecentArticles()
    async let notifications = fetchNotifications()
 
    // 全て完了するまで待機
    return Dashboard(
        user: try await userProfile,
        articles: try await recentArticles,
        notifications: try await notifications
    )
}

func fetchAllAvatars(userIds: [String]) async throws -> [String: UIImage] {
    try await withThrowingTaskGroup(of: (String, UIImage).self) { group in
        // 各ユーザーのアバター取得タスクを追加
        for userId in userIds {
            group.addTask {
                let image = try await fetchAvatar(userId: userId)
                return (userId, image)
            }
        }
 
        // 全タスクの結果を収集
        var avatars: [String: UIImage] = [:]
        for try await (userId, image) in group {
            avatars[userId] = image
        }
        return avatars
    }
}

// 並列数を制限したTaskGroup（同時に最大5件）
func fetchWithConcurrencyLimit<T>(
    items: [T],
    maxConcurrency: Int = 5,
    operation: @Sendable @escaping (T) async throws -> Void
) async throws {
    try await withThrowingTaskGroup(of: Void.self) { group in
        var activeTasks = 0
        var iterator = items.makeIterator()
 
        // 最初のバッチを開始
        while activeTasks < maxConcurrency, let item = iterator.next() {
            group.addTask { try await operation(item) }
            activeTasks += 1
        }
 
        // 完了ごとに次のタスクを追加
        for try await _ in group {
            activeTasks -= 1
            if let item = iterator.next() {
                group.addTask { try await operation(item) }
                activeTasks += 1
            }
        }
    }
}

// WebSocketからのメッセージをAsyncStreamで処理
class WebSocketManager {
    private var webSocket: URLSessionWebSocketTask?
 
    func messageStream(url: URL) -> AsyncStream<String> {
        AsyncStream { continuation in
            let session = URLSession(configuration: .default)
            let webSocket = session.webSocketTask(with: url)
            self.webSocket = webSocket
 
            // メッセージ受信ループ
            Task {
                webSocket.resume()
 
                while !Task.isCancelled {
                    do {
                        let message = try await webSocket.receive()
                        switch message {
                        case .string(let text):
                            continuation.yield(text)
                        case .data(let data):
                            if let text = String(data: data, encoding: .utf8) {
                                continuation.yield(text)
                            }
                        @unknown default:
                            break
                        }
                    } catch {
                        continuation.finish()
                        break
                    }
                }
            }
 
            // キャンセル時のクリーンアップ
            continuation.onTermination = { _ in
                webSocket.cancel()
            }
        }
    }
}
 
// 使用側
let manager = WebSocketManager()
let stream = manager.messageStream(url: wsURL)
 
for await message in stream {
    print("受信: \(message)")
}

// 位置情報をAsyncStreamとして取得
extension CLLocationManager {
    var locationStream: AsyncStream<CLLocation> {
        AsyncStream { continuation in
            let delegate = LocationDelegate(continuation: continuation)
            self.delegate = delegate
            self.startUpdatingLocation()
 
            continuation.onTermination = { [weak self] _ in
                self?.stopUpdatingLocation()
            }
        }
    }
}
 
private class LocationDelegate: NSObject, CLLocationManagerDelegate {
    let continuation: AsyncStream<CLLocation>.Continuation
 
    init(continuation: AsyncStream<CLLocation>.Continuation) {
        self.continuation = continuation
    }
 
    func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
        for location in locations {
            continuation.yield(location)
        }
    }
 
    func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
        continuation.finish()
    }
}
 
// 使用例
let locationManager = CLLocationManager()
for await location in locationManager.locationStream {
    print("現在地: \(location.coordinate)")
}

// @Sendable クロージャ（スレッド安全でなければならない）
func processInBackground<T: Sendable>(
    value: T,
    transform: @Sendable @escaping (T) async throws -> T
) async throws -> T {
    try await Task.detached(priority: .background) {
        try await transform(value)
    }.value
}
 
// Sendable に準拠したデータ構造（値型は自動的にSendable）
struct ArticleMetadata: Sendable {
    let id: String
    let title: String
    let publishedAt: Date
}
 
// クラスでSendableを実現（全プロパティが定数かつSendableである必要がある）
final class ImmutableConfig: Sendable {
    let apiEndpoint: URL
    let apiKey: String
 
    init(apiEndpoint: URL, apiKey: String) {
        self.apiEndpoint = apiEndpoint
        self.apiKey = apiKey
    }
}

// Package.swift での設定
.target(
    name: "MyApp",
    swiftSettings: [
        // 段階的移行: minimal → targeted → complete
        .swiftLanguageMode(.v6)
    ]
)

import XCTest
@testable import MyApp
 
final class ArticleServiceTests: XCTestCase {
    var sut: ArticleService!
    var mockRepository: MockArticleRepository!
 
    @MainActor
    override func setUp() async throws {
        try await super.setUp()
        mockRepository = MockArticleRepository()
        sut = ArticleService(repository: mockRepository)
    }
 
    func testFetchArticlesSuccess() async throws {
        // Given
        let expectedArticles = [
            Article(id: "1", title: "テスト記事1"),
            Article(id: "2", title: "テスト記事2")
        ]
        mockRepository.articlesToReturn = expectedArticles
 
        // When
        let articles = try await sut.fetchArticles()
 
        // Then
        XCTAssertEqual(articles.count, 2)
        XCTAssertEqual(articles[0].title, "テスト記事1")
    }
 
    func testFetchArticlesWithTimeout() async throws {
        // タイムアウトのテスト
        mockRepository.simulateDelay = true
 
        do {
            _ = try await withTimeout(seconds: 1.0) {
                try await self.sut.fetchArticles()
            }
            XCTFail("タイムアウトエラーが発生するべき")
        } catch is TimeoutError {
            // 期待通り
        }
    }
}
 
// タイムアウトヘルパー関数
func withTimeout<T: Sendable>(
    seconds: TimeInterval,
    operation: @escaping @Sendable () async throws -> T
) async throws -> T {
    try await withThrowingTaskGroup(of: T.self) { group in
        group.addTask { try await operation() }
        group.addTask {
            try await Task.sleep(nanoseconds: UInt64(seconds * 1_000_000_000))
            throw TimeoutError()
        }
 
        guard let result = try await group.next() else {
            throw TimeoutError()
        }
        group.cancelAll()
        return result
    }
}
 
struct TimeoutError: Error {}

final class ImageCacheTests: XCTestCase {
    func testCacheStoreAndRetrieve() async {
        let cache = ImageCache()
        let testURL = URL(string: "https://example.com/image.png")!
        let testImage = UIImage(systemName: "star.fill")!
 
        // 保存
        await cache.store(testImage, for: testURL)
 
        // 取得
        let retrieved = await cache.image(for: testURL)
        XCTAssertNotNil(retrieved)
    }
}

// ❌ エラー
let user = fetchUser(id: "123") // 'await' が必要
 
// ✅ 修正
let user = await fetchUser(id: "123") // async コンテキスト内で
// または
let user = try await fetchUser(id: "123") // throws も必要な場合

// ❌ エラー（NSMutableArray は Sendable ではない）
actor DataStore {
    var items: NSMutableArray = []
}
 
// ✅ 修正（Sendable な値型を使う）
actor DataStore {
    var items: [String] = [] // Array<String> は Sendable
}

// ❌ タスクがキャンセルされない
class ViewModel {
    func startPolling() {
        Task { // このTaskはViewModelが解放されても続く
            while true {
                await refresh()
                try await Task.sleep(nanoseconds: 5_000_000_000)
            }
        }
    }
}
 
// ✅ タスクを保持してキャンセル可能にする
class ViewModel {
    private var pollingTask: Task<Void, Never>?
 
    func startPolling() {
        pollingTask = Task {
            while !Task.isCancelled {
                await refresh()
                try? await Task.sleep(nanoseconds: 5_000_000_000)
            }
        }
    }
 
    func stopPolling() {
        pollingTask?.cancel()
        pollingTask = nil
    }
 
    deinit {
        pollingTask?.cancel()
    }
}

// プロトコル定義（テスト容易性のため）
protocol ArticleRepositoryProtocol: Sendable {
    func fetchAll() async throws -> [Article]
    func fetchById(_ id: String) async throws -> Article
    func save(_ article: Article) async throws
}
 
// 本番実装
actor ArticleRepository: ArticleRepositoryProtocol {
    private let apiClient: APIClient
    private let localStorage: LocalStorageProtocol
    private var cache: [String: Article] = [:]
 
    init(apiClient: APIClient, localStorage: LocalStorageProtocol) {
        self.apiClient = apiClient
        self.localStorage = localStorage
    }
 
    func fetchAll() async throws -> [Article] {
        // まずローカルストレージから
        let localArticles = try await localStorage.fetchArticles()
        if !localArticles.isEmpty {
            return localArticles
        }
 
        // なければAPIから取得
        let remoteArticles = try await apiClient.get("/articles", responseType: [Article].self)
 
        // ローカルに保存
        try await localStorage.saveArticles(remoteArticles)
        return remoteArticles
    }
 
    func fetchById(_ id: String) async throws -> Article {
        // キャッシュ確認
        if let cached = cache[id] {
            return cached
        }
 
        let article = try await apiClient.get("/articles/\(id)", responseType: Article.self)
        cache[id] = article
        return article
    }
 
    func save(_ article: Article) async throws {
        try await apiClient.post("/articles", body: article)
        cache[article.id] = article
        try await localStorage.saveArticle(article)
    }
}

enum AppError: Error, LocalizedError {
    case networkUnavailable
    case serverError(statusCode: Int, message: String)
    case decodingError(type: String)
    case unauthorized
    case notFound(id: String)
 
    var errorDescription: String? {
        switch self {
        case .networkUnavailable:
            return "ネットワーク接続を確認してください"
        case .serverError(let code, let message):
            return "サーバーエラー(\(code)): \(message)"
        case .decodingError(let type):
            return "\(type)のデコードに失敗しました"
        case .unauthorized:
            return "ログインが必要です"
        case .notFound(let id):
            return "データが見つかりません: \(id)"
        }
    }
}
 
// 再試行機能付きの非同期実行
func withRetry<T>(
    maxAttempts: Int = 3,
    delay: Duration = .seconds(1),
    operation: @escaping () async throws -> T
) async throws -> T {
    var lastError: Error?
 
    for attempt in 0..<maxAttempts {
        do {
            return try await operation()
        } catch {
            lastError = error
 
            // 再試行不可能なエラーは即座に投げる
            if let appError = error as? AppError, case .unauthorized = appError {
                throw error
            }
 
            // 最後の試行以外は待機
            if attempt < maxAttempts - 1 {
                try await Task.sleep(for: delay * Double(attempt + 1))
            }
        }
    }
 
    throw lastError!
}

// ❌ 再入で重複ダウンロードが走るキャッシュ
actor ThumbnailCache {
    private var cache: [URL: UIImage] = [:]
 
    func image(for url: URL) async throws -> UIImage {
        if let cached = cache[url] {
            return cached
        }
        // ここで await すると、同じ url の別呼び出しがこの間に入り込む
        let (data, _) = try await URLSession.shared.data(from: url)
        let image = UIImage(data: data)!
        cache[url] = image
        return image
    }
}

// ✅ 進行中タスクを共有して重複を防ぐ
actor ThumbnailCache {
    private enum Entry {
        case inProgress(Task<UIImage, Error>)
        case ready(UIImage)
    }
    private var entries: [URL: Entry] = [:]
 
    func image(for url: URL) async throws -> UIImage {
        if let entry = entries[url] {
            switch entry {
            case .ready(let image):
                return image
            case .inProgress(let task):
                return try await task.value  // 既存のダウンロードに相乗りする
            }
        }
        let task = Task<UIImage, Error> {
            let (data, _) = try await URLSession.shared.data(from: url)
            guard let image = UIImage(data: data) else { throw URLError(.cannotDecodeContentData) }
            return image
        }
        entries[url] = .inProgress(task)
        do {
            let image = try await task.value
            entries[url] = .ready(image)
            return image
        } catch {
            entries[url] = nil  // 失敗したら次回リトライできるよう消す
            throw error
        }
    }
}

// 直列(1,180ms平均) → 並列(420ms平均)に置き換えた起動処理
func bootstrap() async throws -> AppBootstrap {
    async let config = remoteConfigClient.fetch()
    async let purchase = purchaseClient.currentStatus()
    async let notices = noticeClient.latest(limit: 5)
    return AppBootstrap(
        config: try await config,
        purchase: try await purchase,
        notices: try await notices
    )
}