SwiftのDispatchQueue処理順序を徹底解説！並列・直列、同期・非同期を理解する⚙️

はじめに (対象読者・この記事でわかること)

この記事は、Swiftで非同期処理を扱う上で欠かせないDispatchQueueの処理順序について、深く理解したいと考えている開発者の方を対象としています。特に、並列（Concurrent）キューと直列（Serial）キュー、そして同期（Synchronous）実行と非同期（Asynchronous）実行の組み合わせによって、処理がどのように制御されるのかを具体的に知りたい方におすすめです。

この記事を読むことで、以下のことがわかるようになります。

• DispatchQueueの基本的な概念と役割
• 並列キューと直列キューの特性の違い
• 同期実行と非同期実行の挙動の違い
• これらの組み合わせによる、具体的な処理順序のパターン
• DispatchQueueを適切に使い分けるためのヒント

複雑に思える非同期処理も、DispatchQueueの仕組みを理解すれば、その挙動を予測し、意図した通りに制御できるようになります。本記事では、具体的なコード例を豊富に交えながら、DispatchQueueの処理順序を徹底的に解説していきます。

前提知識

この記事を読み進める上で、以下の知識があるとスムーズです。

• Swiftの基本的な文法（クロージャ、関数など）
• 並列処理や非同期処理の基本的な概念（完全に理解していなくても大丈夫です）

DispatchQueueの基本: 処理を管理する仕組み

DispatchQueueは、Grand Central Dispatch (GCD) の一部であり、タスク（実行したい処理）をキュー（待ち行列）に入れ、それらを順番に、または同時に実行するための仕組みを提供します。これにより、CPUコアを効率的に利用し、UIの応答性を保つことが可能になります。

DispatchQueueの理解には、以下の2つの軸が重要になります。

1. キューの種類: 処理がどのように「格納」され、実行されるか。
   • 直列 (Serial) キュー: 一度に一つのタスクしか実行せず、タスクは追加された順に実行されます。
   • 並列 (Concurrent) キュー: 複数のタスクを同時に実行できます。CPUコア数やシステムの状態に応じて、同時に実行されるタスクの数は変動します。
2. 実行方法: キューに入れられたタスクを「どのように」実行するか。
   • 同期 (Synchronous) 実行: 現在の処理を一時停止し、指定したタスクが完了するまで待ちます。
   • 非同期 (Asynchronous) 実行: 現在の処理を続行し、指定したタスクはバックグラウンドで実行されます。完了を待ちません。

これらの組み合わせが、DispatchQueueにおける処理順序の鍵となります。

DispatchQueueの処理順序を徹底解説！

DispatchQueueにおける処理順序は、キューの種類（直列か並列か）と実行方法（同期か非同期か）の組み合わせによって、その挙動が大きく変化します。ここでは、それぞれの組み合わせについて、具体的なコード例と共に詳しく解説していきます。

1. 直列キュー + 非同期実行 (async)

直列キューにタスクを非同期で追加した場合、タスクはキューに追加された順に、一つずつ順番に実行されます。現在のスレッドはタスクの完了を待たずに次の処理に進むため、バックグラウンドで実行されることになります。

コード例:

Swift

import Foundation

let serialQueue = DispatchQueue(label: "com.example.serialQueue")

print("--- 直列キュー + 非同期実行 ---")

serialQueue.async {
    print("タスク1 開始")
    Thread.sleep(forTimeInterval: 1) // 1秒待機
    print("タスク1 終了")
}

serialQueue.async {
    print("タスク2 開始")
    Thread.sleep(forTimeInterval: 1) // 1秒待機
    print("タスク2 終了")
}

print("メインスレッドの処理")
Thread.sleep(forTimeInterval: 3) // 非同期タスクの完了を待つため

出力例 (実行環境により多少前後します):

--- 直列キュー + 非同期実行 ---
メインスレッドの処理
タスク1 開始
タスク1 終了
タスク2 開始
タスク2 終了

解説:

• メインスレッドの処理は、asyncでタスクが追加された直後に実行されます。
• タスク1とタスク2は、直列キューに追加された順に、一つずつ実行されます。
• タスク1の完了を待たずにタスク2が開始されることはありません。
• Thread.sleep(forTimeInterval: 3)は、非同期タスクが実行される時間を与えるために置いています。実際には、完了を待つ必要はありません。

2. 直列キュー + 同期実行 (sync)

直列キューにタスクを同期で追加した場合、現在のスレッドはタスクの完了を待ちます。しかし、直列キューは一度に一つのタスクしか実行できないため、問題が発生します。

コード例 (デッドロック発生):

Swift

import Foundation

let serialQueue = DispatchQueue(label: "com.example.serialQueueDeadlock")

print("--- 直列キュー + 同期実行 (デッドロック注意) ---")

serialQueue.sync {
    print("タスク1 開始")
    // ここで同じ直列キューにsyncでタスクを追加するとデッドロックする
    serialQueue.sync {
        print("タスク2 (デッドロック)")
    }
    print("タスク1 終了")
}

print("メインスレッドの処理")

出力例:

このコードを実行すると、アプリケーションが応答しなくなり、デッドロックが発生してプログラムが停止します。

--- 直列キュー + 同期実行 (デッドロック注意) ---
タスク1 開始

解説:

• serialQueue.syncによって、メインスレッド（あるいはこのコードが実行されているスレッド）は、タスク1が完了するまで待機します。
• タスク1の中で、再びserialQueue.syncが呼ばれます。
• しかし、serialQueueは直列キューであるため、現在実行中のタスク1が完了するまで、新しいタスク（タスク2）を実行できません。
• 結果として、タスク1はタスク2の完了を待ち、タスク2はタスク1の完了を待つという、お互いが相手の完了を待ち続ける状態（デッドロック）に陥ります。
• 注意: メインスレッド（UIスレッド）でsyncを実行して、同じメインスレッドのキュー（DispatchQueue.main）にsyncでタスクを追加することも、同様にデッドロックを引き起こします。

3. 並列キュー + 非同期実行 (async)

並列キューにタスクを非同期で追加した場合、タスクはキューに追加された順に、CPUコアが利用可能になり次第、複数同時に実行される可能性があります。現在のスレッドはタスクの完了を待ちません。

コード例:

Swift

import Foundation

let concurrentQueue = DispatchQueue(label: "com.example.concurrentQueue", attributes: .concurrent)

print("--- 並列キュー + 非同期実行 ---")

concurrentQueue.async {
    print("タスクA 開始")
    Thread.sleep(forTimeInterval: 1)
    print("タスクA 終了")
}

concurrentQueue.async {
    print("タスクB 開始")
    Thread.sleep(forTimeInterval: 1)
    print("タスクB 終了")
}

concurrentQueue.async {
    print("タスクC 開始")
    Thread.sleep(forTimeInterval: 1)
    print("タスクC 終了")
}

print("メインスレッドの処理")
Thread.sleep(forTimeInterval: 3) // 非同期タスクの完了を待つため

出力例 (実行環境により多少前後し、タスクの開始順序も変わる可能性があります):

--- 並列キュー + 非同期実行 ---
メインスレッドの処理
タスクA 開始
タスクB 開始
タスクC 開始
タスクA 終了
タスクB 終了
タスクC 終了

解説:

• メインスレッドの処理は、タスクの追加直後に実行されます。
• タスクA, タスクB, タスクCは、システムリソース（CPUコア数など）が許す限り、同時に実行されます。
• 出力順序は、タスクが開始されるタイミングによって変動します。例えば、タスクAが開始されてすぐにタスクB、タスクCも開始される可能性があります。
• 完了順序も、各タスクの処理時間やタイミングによって変動します。

4. 並列キュー + 同期実行 (sync)

並列キューにタスクを同期で追加した場合、現在のスレッドはタスクの完了を待ちます。タスク自体は、並列キューの性質上、他のタスクと同時に（あるいはシステムが許す限り並列に）実行される可能性があります。

コード例:

Swift

import Foundation

let concurrentQueue = DispatchQueue(label: "com.example.concurrentQueueSync", attributes: .concurrent)

print("--- 並列キュー + 同期実行 ---")

print("タスクX 開始")
concurrentQueue.sync {
    print("タスクX 内部処理 開始")
    Thread.sleep(forTimeInterval: 1)
    print("タスクX 内部処理 終了")
}
print("タスクX 終了")

print("メインスレッドの処理")

出力例:

--- 並列キュー + 同期実行 ---
タスクX 開始
タスクX 内部処理 開始
タスクX 内部処理 終了
タスクX 終了
メインスレッドの処理

解説:

• タスクX 開始はすぐに実行されます。
• concurrentQueue.syncにより、タスクX 内部処理が実行され、その完了を待ってからタスクX 終了が実行されます。
• この例では、タスクX 内部処理は並列キューに追加されますが、syncで呼び出されているため、呼び出し元のスレッドは完了を待ちます。もし、このconcurrentQueueに別の非同期タスクが追加されていれば、タスクX 内部処理もそれらと並列に実行される可能性があります（ただし、呼び出し元のスレッドは待機します）。

5. メインキュー (Main Queue)

DispatchQueue.mainは、iOS/macOSアプリケーションにおいてUIの更新を担当する特別な直列キューです。UIの更新は必ずメインキューで行う必要があります。

• メインキュー + 非同期実行 (async): メインキューにタスクを非同期で追加した場合、タスクはメインキューに追加された順に、一つずつ順番に実行されます。UIの更新などでよく利用されます。
• メインキュー + 同期実行 (sync): 絶対に行ってはいけません。 メインキューに同期でタスクを追加すると、デッドロックが発生します。これは、メインキューは直列であり、UIのイベントループもメインキューに依存しているため、実行中のタスクが完了するのを待つ間に、UIイベントループが停止してしまうからです。

コード例 (メインキュー + 非同期実行):

Swift

import Foundation

print("--- メインキュー + 非同期実行 ---")

DispatchQueue.main.async {
    print("UI更新タスク 開始")
    // ここでUIの更新処理を行う
    print("UI更新タスク 終了")
}

print("メインスレッドの処理")
// アプリケーションが実行され続けている間、メインキューのタスクは実行される

出力例:

--- メインキュー + 非同期実行 ---
メインスレッドの処理
UI更新タスク 開始
UI更新タスク 終了

解説:

• UIの更新処理は、必ずDispatchQueue.main.asyncなどを使用して、メインキューにディスパッチする必要があります。
• メインスレッドの処理は、UI更新タスクがキューに追加された直後に実行されます。
• UI更新タスクは、メインキューに追加された順に、一つずつ実行されます。

6. グローバルキュー (Global Queue)

GCDは、システム全体で共有される並列キューであるグローバルキューも提供しています。これらはDispatchQueue.global()で取得できます。優先度に応じて、userInitiated, userInteractive, background, utilityなどのキューがあります。

グローバルキューは並列キューであるため、asyncでタスクを追加すると並列に実行され、syncでタスクを追加すると呼び出し元スレッドは完了を待ちます。

コード例 (グローバルキュー + 非同期実行):

Swift

import Foundation

print("--- グローバルキュー + 非同期実行 ---")

DispatchQueue.global().async {
    print("バックグラウンドタスク1 開始")
    Thread.sleep(forTimeInterval: 1)
    print("バックグラウンドタスク1 終了")
}

DispatchQueue.global().async {
    print("バックグラウンドタスク2 開始")
    Thread.sleep(forTimeInterval: 1)
    print("バックグラウンドタスク2 終了")
}

print("メインスレッドの処理")
Thread.sleep(forTimeInterval: 3)

出力例 (実行環境により多少前後します):

--- グローバルキュー + 非同期実行 ---
メインスレッドの処理
バックグラウンドタスク1 開始
バックグラウンドタスク2 開始
バックグラウンドタスク1 終了
バックグラウンドタスク2 終了

解説:

• グローバルキューは並列キューなので、複数のタスクが同時に実行される可能性があります。
• UIの更新など、特定のスレッドでの実行が必要ないバックグラウンド処理に利用されます。

ハマった点やエラー解決

DispatchQueueを使い始めたばかりの頃、最もよく遭遇する問題はデッドロックです。特に、直列キューやメインキューに対してsyncでタスクをディスパッチした場合に発生しやすく、原因の特定に時間がかかることがあります。

解決策

1. デッドロックの回避:

   • 直列キュー/メインキュー + syncは避ける: ほとんどの場合、同期実行は必要ありません。非同期(async)で実行し、必要であれば完了通知を受け取るように設計しましょう。
   • デバッグ: デッドロックが発生した場合、Xcodeのデバッガでスレッドの状態を確認することが重要です。どのスレッドが、どのキューの完了を待っているのかを追跡することで、問題箇所を特定できます。
   • DispatchQueue.main.syncは絶対に行わない: UIの更新などで非同期処理が必要な場合は、必ずasyncを使用しましょう。

2. 処理順序の理解:

   • 図や表にまとめる: 直列/並列、同期/非同期の4つの組み合わせと、メインキュー/グローバルキューの挙動を図や表にまとめ、いつでも参照できるようにすると理解が深まります。
   • 簡単なコードで実験する: 実際にコードを書き、print文などを仕込んで処理の開始・終了を確認することで、挙動を体験的に理解するのが効果的です。

まとめ

本記事では、SwiftのDispatchQueueにおける処理順序について、キューの種類（直列・並列）と実行方法（同期・非同期）の組み合わせを軸に、具体的なコード例を交えながら徹底的に解説しました。

• 直列キュー: タスクを順番に一つずつ実行する。
• 並列キュー: 複数のタスクを同時に実行できる可能性がある。
• 非同期実行: 現在のスレッドの処理をブロックせずに、タスクをバックグラウンドで実行する。
• 同期実行: 現在のスレッドの処理を一時停止し、タスクの完了を待つ。
• メインキュー: UIの更新など、メインスレッドでの実行が必要なタスクに使用する。
• グローバルキュー: システム全体で共有される並列キュー。

これらの概念を理解し、適切に使い分けることで、より効率的で応答性の高いアプリケーションを開発することができます。特に、デッドロックの発生原因となりやすいsyncの使用には注意が必要です。

今後は、DispatchGroupやDispatchSemaphoreといった、より高度な並列処理制御のためのGCDの機能についても記事にする予定です。

参考資料

• Apple Developer Documentation - Grand Central Dispatch
• Concurrency - Swift (Swift Concurrencyに関するドキュメントですが、GCDの基本にも触れています)