Rork Max × Swift Concurrency 実装ガイド——async/await・Actor・Structured Concurrency でアプリを根本から変える

// 危険なコード：複数スレッドから同時にアクセスされる可能性がある
class UserCache {
    var cache: [String: User] = [:]  // ⚠️ スレッドセーフではない
 
    func store(_ user: User) {
        cache[user.id] = user  // 複数スレッドから呼ばれると競合する
    }
 
    func retrieve(id: String) -> User? {
        return cache[id]  // 読み書きが同時に起きるとクラッシュの可能性
    }
}

// Actor を使ったスレッドセーフなキャッシュ
actor UserCache {
    // Actor 内のプロパティへのアクセスは自動的に直列化される
    private var cache: [String: User] = [:]
    private var lastAccessTime: [String: Date] = [:]
 
    // Actor メソッドはすべて async として扱われる
    func store(_ user: User) {
        cache[user.id] = user
        lastAccessTime[user.id] = Date()
    }
 
    func retrieve(id: String) -> User? {
        return cache[id]
    }
 
    // キャッシュの古いエントリを削除するメソッド
    func pruneExpiredEntries(olderThan threshold: TimeInterval) {
        let cutoff = Date().addingTimeInterval(-threshold)
        let expiredKeys = lastAccessTime
            .filter { $0.value < cutoff }
            .map { $0.key }
 
        expiredKeys.forEach { key in
            cache.removeValue(forKey: key)
            lastAccessTime.removeValue(forKey: key)
        }
    }
}
 
// 使い方
let userCache = UserCache()
 
// Actor の外からアクセスするときは await が必要
Task {
    await userCache.store(User(id: "u1", name: "Masaki"))
    let user = await userCache.retrieve(id: "u1")
    print(user?.name ?? "not found")  // "Masaki"
}

// ViewModel に @MainActor を付けることで UI スレッドの安全性を保証
@MainActor
class ArticleViewModel: ObservableObject {
    @Published var articles: [Article] = []
    @Published var isLoading = false
    @Published var errorMessage: String?
 
    private let apiClient = ArticleAPIClient()
 
    func loadArticles() async {
        isLoading = true
        errorMessage = nil
 
        do {
            // nonisolated なバックグラウンド処理から結果を受け取る
            let fetchedArticles = try await apiClient.fetchAll()
            // ここは @MainActor コンテキストなので UI の更新が安全
            articles = fetchedArticles
        } catch {
            errorMessage = error.localizedDescription
        }
 
        isLoading = false
    }
}
 
// APIClient は @MainActor でなくてよい（バックグラウンドで動く）
struct ArticleAPIClient {
    func fetchAll() async throws -> [Article] {
        let url = URL(string: "https://api.rorklab.net/articles")!
        let (data, _) = try await URLSession.shared.data(from: url)
        return try JSONDecoder().decode([Article].self, from: data)
    }
}

// withTaskGroup を使った並列処理
func fetchMultipleUsers(userIds: [String]) async throws -> [User] {
    try await withThrowingTaskGroup(of: User.self) { group in
        // 複数のユーザーを並列で取得
        for userId in userIds {
            group.addTask {
                return try await UserAPI.fetchUser(userId: userId)
            }
        }
 
        // すべてのタスクが完了するのを待って結果を集める
        var users: [User] = []
        for try await user in group {
            users.append(user)
        }
        return users
    }
    // ここまで到達した時点で、group 内のすべてのタスクは完了している
    // キャンセルや例外が発生した場合も、子タスクはすべて適切にクリーンアップされる
}

// Rork Max ネイティブモジュール：ダッシュボードデータの並列取得
actor DashboardDataManager {
    struct DashboardData {
        let user: User
        let recentArticles: [Article]
        let notifications: [Notification]
        let analytics: Analytics
    }
 
    func fetchDashboardData(userId: String) async throws -> DashboardData {
        // 4つのAPIを並列で呼び出す
        async let user = UserAPI.fetchUser(userId: userId)
        async let articles = ArticleAPI.fetchRecent(limit: 10)
        async let notifications = NotificationAPI.fetchUnread(userId: userId)
        async let analytics = AnalyticsAPI.fetchSummary(userId: userId)
 
        // すべての結果を同時に待つ
        // どれか1つが失敗すると、全体が失敗として処理される
        return try await DashboardData(
            user: user,
            recentArticles: articles,
            notifications: notifications,
            analytics: analytics
        )
        // 期待する動作: 4つのAPI呼び出しが並列で実行され、
        // 直列実行より最大4倍高速になる（各APIが500msかかる場合、合計500ms程度で完了）
    }
}

// キャンセル可能なダウンロードタスク
class ImageDownloadManager {
    private var activeTasks: [String: Task<UIImage, Error>] = [:]
 
    func downloadImage(url: URL, cacheKey: String) async throws -> UIImage {
        // 既存のタスクがあればキャンセルして新しいタスクに置き換える
        activeTasks[cacheKey]?.cancel()
 
        let task = Task {
            // キャンセルチェックポイント：定期的にチェックする
            try Task.checkCancellation()
 
            let (data, response) = try await URLSession.shared.data(from: url)
 
            // もう一度キャンセルを確認（長時間の処理の途中でも確認する）
            try Task.checkCancellation()
 
            guard let httpResponse = response as? HTTPURLResponse,
                  httpResponse.statusCode == 200,
                  let image = UIImage(data: data) else {
                throw ImageError.invalidData
            }
 
            return image
        }
 
        activeTasks[cacheKey] = task
 
        do {
            let image = try await task.value
            activeTasks.removeValue(forKey: cacheKey)
            return image
        } catch {
            activeTasks.removeValue(forKey: cacheKey)
            throw error
        }
    }
 
    func cancelDownload(cacheKey: String) {
        activeTasks[cacheKey]?.cancel()
        activeTasks.removeValue(forKey: cacheKey)
    }
}

// WebSocket のメッセージを AsyncStream で扱う
class WebSocketManager {
    private var webSocketTask: URLSessionWebSocketTask?
 
    func messageStream(url: URL) -> AsyncStream<String> {
        return AsyncStream { continuation in
            // WebSocket 接続を開始
            let session = URLSession(configuration: .default)
            let task = session.webSocketTask(with: url)
            self.webSocketTask = task
 
            // メッセージを継続的に受信するための再帰的な関数
            func receiveNext() {
                task.receive { result in
                    switch result {
                    case .success(let message):
                        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
                        }
                        // 次のメッセージを待つ
                        receiveNext()
 
                    case .failure(let error):
                        print("WebSocket error: \(error)")
                        // エラーが発生したらストリームを終了
                        continuation.finish()
                    }
                }
            }
 
            task.resume()
            receiveNext()
 
            // ストリームがキャンセルされたとき（例：画面が閉じられた）のクリーンアップ
            continuation.onTermination = { _ in
                task.cancel(with: .goingAway, reason: nil)
            }
        }
    }
}
 
// 使い方：SwiftUI View での統合
struct LiveMessageView: View {
    @StateObject private var viewModel = LiveMessageViewModel()
 
    var body: some View {
        List(viewModel.messages, id: \.self) { message in
            Text(message)
        }
        .task {
            // .task モディファイアは View が消えると自動的にキャンセルされる
            await viewModel.startReceiving()
        }
    }
}
 
@MainActor
class LiveMessageViewModel: ObservableObject {
    @Published var messages: [String] = []
 
    private let wsManager = WebSocketManager()
 
    func startReceiving() async {
        let url = URL(string: "wss://api.rorklab.net/ws/messages")!
 
        for await message in wsManager.messageStream(url: url) {
            // @MainActor コンテキストなので直接 @Published を更新できる
            messages.insert(message, at: 0)
 
            // 表示件数を制限
            if messages.count > 100 {
                messages = Array(messages.prefix(100))
            }
        }
    }
}

// Combine Publisher を AsyncStream に変換するヘルパー
extension Publisher where Failure == Never {
    var asyncStream: AsyncStream<Output> {
        AsyncStream { continuation in
            let cancellable = sink { completion in
                continuation.finish()
            } receiveValue: { value in
                continuation.yield(value)
            }
 
            continuation.onTermination = { _ in
                cancellable.cancel()
            }
        }
    }
}
 
// Combine の NotificationCenter を AsyncStream で使う例
func batteryLevelStream() -> AsyncStream<Float> {
    NotificationCenter.default
        .publisher(for: UIDevice.batteryLevelDidChangeNotification)
        .compactMap { _ in UIDevice.current.batteryLevel >= 0 ? UIDevice.current.batteryLevel : nil }
        .asyncStream
}
 
// 使い方
Task {
    UIDevice.current.isBatteryMonitoringEnabled = true
    for await level in batteryLevelStream() {
        print("バッテリー残量: \(Int(level * 100))%")
        if level < 0.2 {
            // 低バッテリー警告をユーザーに表示
            await showLowBatteryAlert()
        }
    }
}

// ❌ データ競合の警告が出るコード
class DataService {
    var data: [String] = []
 
    func process() async {
        // Warning: Sending 'self.data' risks causing data races
        await Task.detached {
            self.data.append("new item")  // 危険：data は Sendable でない
        }.value
    }
}
 
// ✅ Actor を使って修正
actor DataService {
    var data: [String] = []
 
    func process() async {
        data.append("new item")  // Actor 内なので安全
    }
}

// ❌ 同一の Actor コンテキストからブロッキング呼び出しをしてしまうパターン
@MainActor
class ViewModel {
    func badPattern() {
        // ❌ MainActor から Task.init して同じ MainActor を await すると
        //    状況によってデッドロックが発生することがある
        let result = Task {
            await someMainActorWork()  // 同じ MainActor を待機
        }
        // result.value を同期的に待とうとすると問題が起きる
    }
 
    // ✅ 正しいパターン：async メソッドとして定義する
    func goodPattern() async {
        await someMainActorWork()
    }
}

// ❌ Task がキャンセルされない
class BadViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        // この Task は viewController が解放されても動き続ける
        Task {
            for await update in dataStream() {
                self.updateUI(update)  // self が解放されていても呼ばれる可能性
            }
        }
    }
}
 
// ✅ Task を保持してキャンセルする
class GoodViewController: UIViewController {
    private var streamTask: Task<Void, Never>?
 
    override func viewDidLoad() {
        super.viewDidLoad()
        streamTask = Task { [weak self] in
            guard let self else { return }
            for await update in dataStream() {
                await MainActor.run {
                    self.updateUI(update)
                }
            }
        }
    }
 
    override func viewDidDisappear(_ animated: Bool) {
        super.viewDidDisappear(animated)
        streamTask?.cancel()
        streamTask = nil
    }
}

// Rork Max ネイティブモジュール：Swift Concurrency を正しく使った実装
@objc(RorkDataModule)
class RorkDataModule: NSObject {
 
    // RCT_EXPORT_METHOD は同期コンテキストのため、Task でラップする
    @objc func fetchData(_ query: String,
                         resolve: @escaping RCTPromiseResolveBlock,
                         reject: @escaping RCTPromiseRejectBlock) {
        // detached Task を使うことで、呼び出し元の Actor 継承を避ける
        Task.detached(priority: .userInitiated) {
            do {
                let result = try await DataService.shared.search(query: query)
                // resolve/reject は JS スレッドで呼ばれることが期待されているため、
                // メインスレッドからの呼び出しが安全
                await MainActor.run {
                    resolve(result)
                }
            } catch {
                await MainActor.run {
                    reject("SEARCH_ERROR", error.localizedDescription, error)
                }
            }
        }
    }
}
 
// 中核のデータサービス：Actor で実装
actor DataService {
    static let shared = DataService()
 
    private var cache: [String: [SearchResult]] = [:]
 
    func search(query: String) async throws -> [[String: Any]] {
        // キャッシュヒット
        if let cached = cache[query] {
            return cached.map { $0.toDictionary() }
        }
 
        // API 呼び出し
        let results = try await SearchAPI.search(query: query)
        cache[query] = results
 
        return results.map { $0.toDictionary() }
    }
}

// パフォーマンス計測用のラッパー
func measureAsync<T>(_ label: String, operation: () async throws -> T) async throws -> T {
    let start = CFAbsoluteTimeGetCurrent()
    let result = try await operation()
    let elapsed = CFAbsoluteTimeGetCurrent() - start
    print("⏱ \(label): \(String(format: "%.3f", elapsed * 1000))ms")
    return result
}
 
// 使用例
let dashboardData = try await measureAsync("ダッシュボード並列取得") {
    try await dashboardManager.fetchDashboardData(userId: currentUserId)
}
// 期待する出力例: ⏱ ダッシュボード並列取得: 312.456ms
// （直列なら約1200ms かかるところを並列化で1/4 に短縮）

@MainActor
class FeedViewModel: ObservableObject {
    @Published var items: [FeedItem] = []
 
    func refresh() {
        // ❌ この Task は @MainActor を継承するため、
        //    重い JSON デコードまでメインスレッドで動いてしまう
        Task {
            let data = try? await api.fetchFeed()        // ネットワークは OK（await で手放す）
            let decoded = heavyDecode(data)              // ⚠️ これがメインスレッドを占有する
            items = decoded
        }
    }
 
    func refreshCorrect() {
        // ✅ デコードのような CPU バウンドな処理は detached に逃がす
        Task {
            let data = try? await api.fetchFeed()
            let decoded = await Task.detached(priority: .userInitiated) {
                heavyDecode(data)                        // バックグラウンドで実行
            }.value
            items = decoded                              // @MainActor に戻って UI 更新
        }
    }
}

actor ImageLoader {
    private var cache: [URL: UIImage] = [:]
    private var inFlight: [URL: Task<UIImage, Error>] = [:]
 
    func image(for url: URL) async throws -> UIImage {
        if let cached = cache[url] { return cached }
        // ✅ 進行中のタスクを共有することで二重取得を防ぐ
        if let existing = inFlight[url] { return try await existing.value }
 
        let task = Task { try await download(url) }
        inFlight[url] = task
        defer { inFlight[url] = nil }
 
        let image = try await task.value
        cache[url] = image
        return image
    }
}