Swiftで理解するDispatchSemaphoreの使い方15選

はじめに
●DispatchSemaphoreとは
- ○DispatchSemaphoreの基本
●DispatchSemaphoreの使い方
●DispatchSemaphoreの応用例
●注意点と対処法
- ○DispatchSemaphoreの誤った使用と対策
  - □セマフォの値の誤解
  - □セマフォの不適切なリリース
- ○セマフォのデッドロックの回避方法
  - □リソースの取得順序を固定する
  - □タイムアウトを設定する
●カスタマイズ方法
- ○DispatchSemaphoreの拡張とカスタマイズのテクニック
  - □非同期処理の終了を感知する拡張
  - □タイムアウト時間を指定してセマフォを実行する拡張
まとめ

はじめに

近年、多くのアプリケーションやシステムで非同期処理の需要が高まっています。

Swiftはこの非同期処理を効果的に制御するための多くのツールやライブラリを提供しており、その中でも「DispatchSemaphore」は特に重要な役割を果たしています。

この記事では、SwiftでのDispatchSemaphoreの使用方法を、初心者から上級者まで幅広く理解できるよう、詳細な説明とサンプルコードを交えて解説します。

応用例や注意点も網羅しているので、DispatchSemaphoreの効果的な使用方法を身につける上で非常に役立つ内容となっています。

●DispatchSemaphoreとは

DispatchSemaphoreは、特定のリソースやタスクにアクセスできるスレッドの数を制御するためのツールです。

これは、複数のスレッドが同時に同一のリソースにアクセスすることを防ぐため、または非同期処理の完了を待つために使用されます。

Semaphoreは「信号」という意味で、実際には「許可証」のような役割を果たします。

許可証の数だけ同時にリソースにアクセスできるスレッドが存在でき、その上限を超えるスレッドは待機状態になります。

例えば、5つのスレッドがあり、3つの許可証がある場合、最初の3つのスレッドはすぐにリソースにアクセスできますが、残りの2つのスレッドは待機状態となります。

1つのスレッドがリソースのアクセスを終了すると、そのスレッドが許可証を返却し、待機していたスレッドの中から1つがリソースにアクセスすることができるようになります。

このように、DispatchSemaphoreを使用することで、非同期処理においてもリソースへのアクセスを安全に、かつ効率的に制御することができます。

○DispatchSemaphoreの基本

DispatchSemaphoreの使用は非常にシンプルです。

まず、Semaphoreのインスタンスを作成します。

この際、許可証の数を指定することができます。

そして、スレッドがリソースにアクセスする前に「wait」メソッドを呼び出し、アクセス後に「signal」メソッドを呼び出して許可証を返却します。

具体的には、次のような流れになります。

DispatchSemaphoreのインスタンスを作成し、許可証の数を指定する。
スレッドがリソースにアクセスする前に「wait」を呼び出す。
リソースへのアクセスが完了したら、「signal」を呼び出して許可証を返却する。

この基本的な流れを理解すれば、非同期処理におけるリソースの同時アクセスを効果的に制御することができるようになります。

●DispatchSemaphoreの使い方

DispatchSemaphoreは、Swiftで非同期処理を行う際の同期制御に非常に役立つツールです。

ここでは、DispatchSemaphoreの基本的な使用法から、より高度な使い方までをサンプルコードを交えて解説します。

○サンプルコード1：基本的なDispatchSemaphoreの使用

DispatchSemaphoreを使用する最も基本的な方法は、非同期処理の完了を待つことです。

このコードではDispatchSemaphoreを使って、非同期処理が完了するのを待つコードを表しています。

この例では非同期処理を行い、その処理が完了するまでメインスレッドをブロックしています。

import Dispatch

let semaphore = DispatchSemaphore(value: 1)

DispatchQueue.global().async {
    // 非同期処理
    sleep(2)
    print("非同期処理完了")
    semaphore.signal()
}

semaphore.wait()
print("メインスレッド再開")

このコードを実行すると、まず非同期処理が開始され、2秒後に”非同期処理完了”と表示されます。

その後、メインスレッドが”メインスレッド再開”と表示します。

○サンプルコード2：DispatchSemaphoreでの非同期タスクの同期

DispatchSemaphoreを使って、複数の非同期タスクを同期的に実行することも可能です。

このコードではDispatchSemaphoreを使って、2つの非同期タスクを順番に実行するコードを表しています。

この例では2つの非同期タスクを連続して実行し、各タスクが完了するのを待ってから次のタスクを開始しています。

import Dispatch

let semaphore = DispatchSemaphore(value: 1)

DispatchQueue.global().async {
    semaphore.wait()
    // 1つ目の非同期処理
    sleep(2)
    print("1つ目の非同期処理完了")
    semaphore.signal()
}

DispatchQueue.global().async {
    semaphore.wait()
    // 2つ目の非同期処理
    sleep(2)
    print("2つ目の非同期処理完了")
    semaphore.signal()
}

このコードを実行すると、1つ目の非同期処理が開始され、2秒後に”1つ目の非同期処理完了”と表示され、次に2つ目の非同期処理が開始され、2秒後に”2つ目の非同期処理完了”と表示されます。

○サンプルコード3：複数の非同期タスクを制御

複数の非同期タスクを同時に実行し、すべてのタスクが完了するのを待つ場合にも、DispatchSemaphoreを利用できます。

このコードではDispatchSemaphoreを使って、3つの非同期タスクを同時に実行し、すべてのタスクが完了するのを待つコードを表しています。

import Dispatch

let semaphore = DispatchSemaphore(value: 3)

for i in 1...3 {
    DispatchQueue.global().async {
        semaphore.wait()
        // 非同期処理
        sleep(2)
        print("\(i)つ目の非同期処理完了")
        semaphore.signal()
    }
}

このコードを実行すると、3つの非同期タスクが同時に開始され、それぞれ2秒後に完了メッセージが表示されます。

○サンプルコード4：DispatchSemaphoreを使ったタイムアウト処理

DispatchSemaphoreはタイムアウト処理もサポートしています。

このコードではDispatchSemaphoreを使って、非同期処理のタイムアウトを制御するコードを表しています。

この例では非同期処理が3秒かかる場合、2秒後にタイムアウトして処理を中断する方法を示しています。

import Dispatch

let semaphore = DispatchSemaphore(value: 1)

DispatchQueue.global().async {
    // 非同期処理（3秒かかる）
    sleep(3)
    semaphore.signal()
}

if semaphore.wait(timeout: .now() + 2) == .timedOut {
    print("タイムアウトしました")
} else {
    print("非同期処理完了")
}

このコードを実行すると、”タイムアウトしました”と表示され、非同期処理は中断されます。

●DispatchSemaphoreの応用例

DispatchSemaphoreは、複数の非同期タスクが同時に実行されるのを防ぐための仕組みとして知られています。

ここでは、その応用例を2つ紹介します。

○サンプルコード5：非同期タスクの結果を順次取得

非同期タスクを実行する際に、タスクの結果を順序を守って取得することが求められる場面もあります。

DispatchSemaphoreを活用することで、このような要件も実現できます。

import Dispatch

let semaphore = DispatchSemaphore(value: 0)
let queue = DispatchQueue.global()

queue.async {
    print("タスク1を実行")
    sleep(2)
    print("タスク1完了")
    semaphore.signal()
}

queue.async {
    semaphore.wait()
    print("タスク2を実行")
    sleep(1)
    print("タスク2完了")
    semaphore.signal()
}

queue.async {
    semaphore.wait()
    print("タスク3を実行")
    print("タスク3完了")
}

このコードでは、DispatchSemaphoreと非同期のキューを使って3つのタスクを実行しています。

semaphore.wait()により、前のタスクが完了するまで次のタスクが待機されます。

結果として、タスクは必ず「タスク1 -> タスク2 -> タスク3」の順で実行されます。

このコードを実行すると、出力は次のようになります。

タスク1を実行
タスク1完了
タスク2を実行
タスク2完了
タスク3を実行
タスク3完了

このように、タスクが順序通りに実行されることが確認できます。

○サンプルコード6：非同期のエラー処理

非同期の処理中にエラーが発生した場合、エラーの内容や発生タイミングに応じて適切なエラー処理を行いたいと思うでしょう。

DispatchSemaphoreを利用して、エラー処理を行う方法を解説します。

import Dispatch

let semaphore = DispatchSemaphore(value: 0)
let queue = DispatchQueue.global()
var isErrorOccurred = false

queue.async {
    print("タスク1を実行")
    sleep(2)

    if isErrorOccurred {
        print("エラーが発生したのでタスク1を終了")
        semaphore.signal()
        return
    }

    print("タスク1完了")
    semaphore.signal()
}

queue.async {
    semaphore.wait()

    print("タスク2を実行")
    // エラーをシミュレート
    isErrorOccurred = true
    print("エラー発生！")
    semaphore.signal()
}

queue.async {
    semaphore.wait()

    if isErrorOccurred {
        print("エラーが発生したのでタスク3をスキップ")
        return
    }

    print("タスク3を実行")
    print("タスク3完了")
}

上記のコードでは、タスク2でエラーがシミュレートされています。

そのため、次のタスク3はエラー発生の確認を行い、エラーが発生していれば実行をスキップします。

このコードを実行すると、次のような出力結果となります。

タスク1を実行
タスク1完了
タスク2を実行
エラー発生！
エラーが発生したのでタスク3をスキップ

○サンプルコード7：DispatchSemaphoreを使ったリトライ処理

非同期処理において、何らかの理由でタスクが失敗することはよくあります。

そのような場合にリトライ（再試行）機能を組み込むことで、一時的なエラーを乗り越えてタスクを成功させることが期待されます。

ここでは、DispatchSemaphoreを利用してリトライ処理を実装する方法を紹介します。

import Foundation

func retryTaskWithSemaphore(maxRetryCount: Int, task: () throws -> Void) {
    let semaphore = DispatchSemaphore(value: 0)

    for _ in 0..<maxRetryCount {
        do {
            try task()
            return
        } catch {
            print("タスクが失敗しました。再試行します。")
            _ = semaphore.wait(timeout: .now() + 2.0) // 2秒待機して再試行
        }
    }
    print("最大再試行回数に達しました。")
}

このコードでは、retryTaskWithSemaphore関数を使って、指定した回数だけ非同期タスクの再試行を行います。

非同期タスクが成功した場合は処理を終了し、失敗した場合は指定した時間だけ待機してから再試行します。

この例を用いて、サーバーへのリクエストが一時的に失敗した場合などに再試行するような処理を実装することができます。

このコードを実行すると、非同期タスクが成功するまで、または最大再試行回数に達するまで、再試行が繰り返されます。

○サンプルコード8：非同期タスクの途中終了

非同期タスクを実行している最中に、ユーザーの操作や他のイベントにより、そのタスクを中断する必要が生じることがあります。

DispatchSemaphoreを使用して、非同期タスクの途中での終了を制御する方法を見てみましょう。

import Foundation

func interruptibleTaskWithSemaphore(task: (DispatchSemaphore) throws -> Void) {
    let semaphore = DispatchSemaphore(value: 1)

    DispatchQueue.global().async {
        do {
            try task(semaphore)
        } catch {
            print("タスクが中断されました。")
        }
    }

    // タスク中断のシミュレーション
    sleep(2) // 2秒後にタスクを中断
    semaphore.signal()
}

このコードでは、interruptibleTaskWithSemaphore関数を使って、非同期タスクを途中で中断する機能を実装しています。

非同期タスクが実行されている間に、セマフォのsignal()メソッドを呼び出すことで、タスクを中断することができます。

この例を用いて、長時間かかる非同期処理を実行している最中に、ユーザーがキャンセルボタンを押した場合などに、非同期タスクを中断するような処理を実装することができます。

このコードを実行すると、非同期タスクが2秒後に中断され、「タスクが中断されました」というメッセージが表示されます。

○サンプルコード9：複数のセマフォを組み合わせる

SwiftのDispatchSemaphoreは非同期タスクの制御のための強力なツールですが、複数のセマフォを組み合わせることで、より高度な同期制御が可能となります。

ここでは、複数のセマフォを組み合わせる方法について解説します。

このコードでは、複数のDispatchSemaphoreを使用して、複数の非同期タスクの完了を待つコードを表しています。

この例では、2つの非同期タスクを実行し、それぞれの完了を待つための2つのセマフォを使用しています。

import Foundation

let semaphore1 = DispatchSemaphore(value: 0)
let semaphore2 = DispatchSemaphore(value: 0)

DispatchQueue.global().async {
    print("非同期タスク1を開始")
    sleep(2)
    print("非同期タスク1を完了")
    semaphore1.signal()
}

DispatchQueue.global().async {
    print("非同期タスク2を開始")
    sleep(3)
    print("非同期タスク2を完了")
    semaphore2.signal()
}

semaphore1.wait()
semaphore2.wait()
print("両方の非同期タスクが完了")

このコードを実行すると、まず「非同期タスク1を開始」と「非同期タスク2を開始」という2つのメッセージが表示されます。

その後、それぞれの非同期タスクが完了したタイミングで「非同期タスク1を完了」と「非同期タスク2を完了」というメッセージが表示されます。

最後に、「両方の非同期タスクが完了」というメッセージが表示されることで、2つの非同期タスクが順番に完了したことが確認できます。

○サンプルコード10：セマフォとDispatchGroupの組み合わせ

DispatchGroupを使用することで、複数の非同期タスクがすべて完了したことを検知することができます。

ここでは、DispatchSemaphoreとDispatchGroupを組み合わせることで、非同期タスクの同期制御を行う方法について解説します。

このコードでは、DispatchGroupを使って複数の非同期タスクの完了を検知し、その後でDispatchSemaphoreを使用してメインスレッド上での処理を同期させるコードを表しています。

この例では、3つの非同期タスクを実行し、すべてのタスクが完了した時点でメインスレッド上での処理を実行しています。

import Foundation

let group = DispatchGroup()
let semaphore = DispatchSemaphore(value: 0)

for i in 1...3 {
    group.enter()
    DispatchQueue.global().async {
        print("非同期タスク\(i)を開始")
        sleep(UInt32(i))
        print("非同期タスク\(i)を完了")
        group.leave()
    }
}

group.notify(queue: DispatchQueue.global()) {
    print("すべての非同期タスクが完了")
    semaphore.signal()
}

semaphore.wait()
print("メインスレッドでの処理を開始")

このコードを実行すると、まず「非同期タスク1を開始」、「非同期タスク2を開始」、「非同期タスク3を開始」という3つのメッセージが表示されます。

それぞれの非同期タスクが完了したタイミングで、対応する「非同期タスク1を完了」、「非同期タスク2を完了」、「非同期タスク3を完了」というメッセージが表示されます。

全ての非同期タスクが完了した後で、「すべての非同期タスクが完了」というメッセージが表示され、最後に「メインスレッドでの処理を開始」というメッセージが表示されます。

○サンプルコード11：非同期処理のキャンセル

非同期処理のキャンセルは、アプリの動作において非常に重要です。

タスクが長時間かかる場合や、ユーザーが操作をキャンセルした場合に、それを速やかに中止する方法を知っておくことは役立ちます。

SwiftのDispatchSemaphoreを使用することで、このようなキャンセル操作を簡単に行うことができます。

import Foundation

// 非同期タスクの実行クラス
class AsyncTask {
    var isCancelled = false
    let semaphore = DispatchSemaphore(value: 1)

    func execute() {
        DispatchQueue.global().async {
            for i in 1...10 {
                if self.isCancelled {
                    print("タスクがキャンセルされました。")
                    return
                }
                print("タスク実行中 \(i)")
                sleep(1)
            }
        }
    }

    func cancel() {
        semaphore.wait()
        isCancelled = true
        semaphore.signal()
    }
}

let task = AsyncTask()
task.execute()
DispatchQueue.global().asyncAfter(deadline: .now() + 3) {
    task.cancel()
}

このコードでは、AsyncTaskクラスを使って非同期処理のキャンセルを行っています。

executeメソッドで非同期タスクを実行し、その3秒後にcancelメソッドを呼び出してタスクをキャンセルしています。

isCancelledフラグとセマフォを組み合わせて、タスクのキャンセル状態を安全に管理しています。

タスクがキャンセルされた場合、”タスクがキャンセルされました。”と表示され、それ以降のタスク実行は中止されます。

○サンプルコード12：非同期処理のデバッグ

非同期処理のデバッグは、同期処理に比べて難しくなることが多いです。

DispatchSemaphoreを使用することで、非同期処理のデバッグも容易に行えるようになります。

import Foundation

// 非同期タスクの実行クラス
class DebuggableTask {
    let semaphore = DispatchSemaphore(value: 0)

    func execute() {
        DispatchQueue.global().async {
            print("タスク開始")
            sleep(2)
            print("タスク完了")
            self.semaphore.signal()
        }
    }

    func waitForCompletion() {
        semaphore.wait()
    }
}

let task = DebuggableTask()
task.execute()
task.waitForCompletion()
print("全てのタスクが完了しました。")

このコードでは、DebuggableTaskクラスを使用して、非同期処理のデバッグをサポートしています。

executeメソッドで非同期タスクを実行した後、waitForCompletionメソッドでタスクの完了を待つことができます。

“全てのタスクが完了しました。”というメッセージが表示されることで、非同期タスクが正常に完了したことが確認できます。

○サンプルコード13：セマフォを使用した排他制御

DispatchSemaphoreを使用すると、排他制御を簡単に実装することができます。

排他制御は、同時にアクセスできるスレッド数を制限して、データの競合や不整合を防ぐためのものです。

例えば、複数のスレッドから同時にデータを書き込みたい場面があるとします。

しかし、同時に複数のスレッドがデータにアクセスすると、データが壊れたり、期待しない動作をする恐れがあります。

そんなとき、DispatchSemaphoreを用いると、一度に1つのスレッドのみがアクセスできるように制限することができます。

ここでは、セマフォを使用して排他制御を行うサンプルコードを紹介します。

import Foundation

// 共有データ
var sharedData: Int = 0

// セマフォの作成（同時にアクセスできるスレッド数を1に制限）
let semaphore = DispatchSemaphore(value: 1)

// 複数のスレッドでデータを変更
DispatchQueue.concurrentPerform(iterations: 10) { _ in
    // セマフォを待機
    semaphore.wait()

    // 共有データの操作
    sharedData += 1
    print("Data updated by thread: \(Thread.current)")

    // セマフォの解放
    semaphore.signal()
}

print("Final shared data value: \(sharedData)")

このコードでは、共有データsharedDataを10のスレッドが同時にアクセスして更新します。

しかし、セマフォの制限により、実際には1つのスレッドのみが一度にアクセスできます。

そのため、最終的なsharedDataの値は10となります。

○サンプルコード14：非同期処理の優先順位の制御

DispatchQueueを使用して非同期処理を行う際、特定のタスクに優先順位を付けたい場面があります。

DispatchSemaphoreと組み合わせることで、非同期処理の優先順位を制御することができます。

下記のサンプルコードでは、2つの非同期タスクを実行し、一方のタスクに高い優先順位を付けています。

import Foundation

let semaphore = DispatchSemaphore(value: 1)

// 低優先度のタスク
DispatchQueue.global(qos: .default).async {
    semaphore.wait()
    print("Low priority task is running")
    sleep(2)
    print("Low priority task completed")
    semaphore.signal()
}

// 高優先度のタスク
DispatchQueue.global(qos: .userInitiated).async {
    semaphore.wait()
    print("High priority task is running")
    semaphore.signal()
}

上記のコードでは、低優先度のタスクは2秒間スリープしますが、高優先度のタスクはすぐに終了します。

しかし、どちらのタスクもセマフォの制限により同時に実行されることはありません。

○サンプルコード15：セマフォのカスタム拡張

DispatchSemaphoreは非常に便利なクラスですが、特定のユースケースに合わせて拡張したい場合もあります。

ここでは、DispatchSemaphoreを継承してカスタムのセマフォを作成する例を紹介します。

import Foundation

class CustomSemaphore: DispatchSemaphore {
    var identifier: String

    init(value: Int, identifier: String) {
        self.identifier = identifier
        super.init(value: value)
    }

    override func wait() -> DispatchTimeoutResult {
        print("Waiting for semaphore with ID: \(identifier)")
        return super.wait()
    }

    override func signal() -> Int {
        print("Releasing semaphore with ID: \(identifier)")
        return super.signal()
    }
}

let customSemaphore = CustomSemaphore(value: 1, identifier: "CustomSemaphore_001")
customSemaphore.wait()
print("Working with custom semaphore...")
customSemaphore.signal()

このカスタムセマフォCustomSemaphoreは、通常のセマフォの機能に加え、セマフォの識別子を持ち、待機と解放の際にログを出力する機能を追加しています。

これにより、複雑なアプリケーションのデバッグ時に、どのセマフォが動作しているかを容易に判断することができます。

●注意点と対処法

SwiftのDispatchSemaphoreを使う際には、正しく使用しないと、プログラムの動作が不安定になったり、予期しないエラーが発生するリスクがあります。

ここでは、DispatchSemaphoreの使用時の主な注意点と、それに対する対処法について詳しく解説します。

○DispatchSemaphoreの誤った使用と対策

DispatchSemaphoreは非常に強力なツールであり、多くの同期問題を解決することができます。

しかし、誤った使い方をすると、逆に問題を引き起こすことがあります。

□セマフォの値の誤解

セマフォは、特定のリソースにアクセスできるスレッドの数を制御するものであり、初期値として設定する値が重要です。

この値を誤解すると、アクセスの制御がうまく行かなくなります。

let semaphore = DispatchSemaphore(value: 2)

このコードでは、最大で2つのスレッドが同時にリソースにアクセスできるようにセマフォを設定しています。

初期値を適切に設定することで、リソースのアクセス制御が適切に行われます。

□セマフォの不適切なリリース

セマフォは、リソースにアクセスした後、正しくリリースする必要があります。

リリースを忘れると、他のスレッドがそのリソースにアクセスできなくなってしまいます。

semaphore.wait()
// 何らかの処理
semaphore.signal()

このコードでは、セマフォを使用してリソースにアクセスした後、必ずsignal()メソッドを呼び出してセマフォをリリースしています。

このように、正しくリリースすることで、他のスレッドもリソースにアクセスできるようになります。

○セマフォのデッドロックの回避方法

デッドロックは、複数のスレッドが互いに必要なリソースを持っており、どちらもリソースをリリースしないために、どちらのスレッドも進行できなくなる状態を指します。

セマフォを使用する際には、このデッドロックを回避するための注意が必要です。

□リソースの取得順序を固定する

複数のリソースを取得する必要がある場合、すべてのスレッドでリソースの取得順序を同じにすることで、デッドロックのリスクを低減することができます。

let semaphoreA = DispatchSemaphore(value: 1)
let semaphoreB = DispatchSemaphore(value: 1)

semaphoreA.wait()
// リソースAの処理
semaphoreB.wait()
// リソースBの処理

semaphoreB.signal()
semaphoreA.signal()

このコードでは、すべてのスレッドがリソースAを先に取得し、次にリソースBを取得する順序を固定しています。

これにより、デッドロックのリスクを低減することができます。

□タイムアウトを設定する

デッドロックが発生した場合、永遠にスレッドが停止してしまう可能性があります。

これを回避するためには、セマフォのwait()メソッドにタイムアウトを設定することで、一定時間後に強制的にリソースの取得を諦めることができます。

let result = semaphore.wait(timeout: .now() + 5)
if result == .timedOut {
    // タイムアウト時の処理
}

このコードでは、セマフォの取得を最大5秒間待機します。5秒経過しても取得できない場合、タイムアウトとして処理を進めることができます。

●カスタマイズ方法

DispatchSemaphoreは、Swiftにおいて非同期処理を同期的に扱うためのツールとして頻繁に使用されます。

しかし、これをさらに応用してカスタマイズを加えることで、さまざまな場面でより効果的に利用することが可能です。

ここでは、DispatchSemaphoreの拡張とカスタマイズのテクニックに焦点を当てて解説していきます。

○DispatchSemaphoreの拡張とカスタマイズのテクニック

□非同期処理の終了を感知する拡張

このコードでは、非同期処理が完了した際に何らかの処理を追加で実行するカスタム拡張を表しています。

この例では、非同期処理の終了を感知してログを出力しています。

import Foundation

extension DispatchSemaphore {
    func waitThenPerform(_ task: () -> Void) {
        self.wait()
        task()
        print("非同期処理完了")
    }
}

let semaphore = DispatchSemaphore(value: 1)
DispatchQueue.global().async {
    semaphore.wait()
    sleep(2)
    semaphore.signal()
}

semaphore.waitThenPerform {
    print("カスタマイズされた非同期処理の終了処理を実行")
}

このコードを実行すると、まず非同期処理が行われ、その後「カスタマイズされた非同期処理の終了処理を実行」と「非同期処理完了」というログが順番に出力されます。

□タイムアウト時間を指定してセマフォを実行する拡張

このコードでは、指定されたタイムアウト時間内で非同期処理が完了しなかった場合に、タイムアウトとして特定の処理を実行するカスタム拡張を表しています。

この例では、タイムアウト時間を3秒と設定し、それを超えると「タイムアウト発生」というログを出力しています。

extension DispatchSemaphore {
    func waitWithTimeout(_ timeout: TimeInterval, then task: @escaping () -> Void) {
        let result = self.wait(timeout: .now() + timeout)
        if result == .timedOut {
            print("タイムアウト発生")
            task()
        }
    }
}

let semaphore = DispatchSemaphore(value: 1)
DispatchQueue.global().async {
    semaphore.wait()
    sleep(4)
    semaphore.signal()
}

semaphore.waitWithTimeout(3) {
    print("カスタマイズされたタイムアウト処理を実行")
}

このコードを実行すると、非同期処理が4秒かかるため、3秒のタイムアウト時間を超え、「タイムアウト発生」と「カスタマイズされたタイムアウト処理を実行」というログが出力されます。