非同期処理

AsyncProgramming.swift

import Foundation
import PlaygroundSupport
PlaygroundPage.current.needsIndefiniteExecution = true

DispatchQueue.main.async {
    print("メインスレッドで非同期実行")
}

DispatchQueue(label: "").async {
    print("サブスレッド（直列キュー）で非同期実行")
}

DispatchQueue(label: "", attributes: .concurrent).async {
    print("サブスレッド（並列キュー）で非同期実行")
}

DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 1.0) {
    print("非同期で遅延実行")
}

class APIClient {
    enum API: String {
        case a
        case b
        case c
    }
    
    func request(api: API, completion: @escaping () -> Void) {
        print("API(\(api.rawValue))のリクエスト開始")
        DispatchQueue(label: "", attributes: .concurrent).asyncAfter(deadline: DispatchTime.now() + Double.random(in: 0...1)) {
            print("API(\(api.rawValue))のリクエスト完了")
            completion()
        }
    }
}

let apiClient = APIClient()

// 直列にAPIリクエスト
apiClient.request(api: .a) {
    apiClient.request(api: .b) {
        apiClient.request(api: .c) {
            print("直列にAPIリクエスト完了")
        }
    }
}

// 並列にAPIリクエスト
let group = DispatchGroup()
let queue = DispatchQueue.main

queue.async(group: group) {
    group.enter()
    apiClient.request(api: .a) {
        group.leave()
    }
}

queue.async(group: group) {
    group.enter()
    apiClient.request(api: .b) {
        group.leave()
    }
}

queue.async(group: group) {
    group.enter()
    apiClient.request(api: .c) {
        group.leave()
    }
}

group.notify(queue: queue) {
    print("並列にAPIリクエスト完了")
}

// 非同期タスクのキャンセル
let aWorkItem = DispatchWorkItem() {
    apiClient.request(api: .a) {
    }
}

let bWorkItem = DispatchWorkItem() {
    apiClient.request(api: .b) {
    }
}

let cWorkItem = DispatchWorkItem() {
    apiClient.request(api: .c) {
    }
}

DispatchQueue.main.async(execute: aWorkItem)
DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 0.1, execute: bWorkItem)
DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 0.2, execute: cWorkItem)

bWorkItem.cancel()
cWorkItem.cancel()