Objective-Cでのセマフォの使い方解説！初心者が理解できる10のステップ

はじめに
●Objective-Cとは
- ○Objective-Cの特徴
- ○Objective-Cでよく使用される概念
●セマフォとは
- ○セマフォの役割と基本的な概念
- ○セマフォの種類
●Objective-Cでのセマフォの基本的な使い方
- ○サンプルコード1：セマフォの基本的な使用方法
- ○サンプルコード2：セマフォを使った同期処理
●Objective-Cでのセマフォの応用例
●セマフォを使う際の注意点と対処法
- ○デッドロックのリスクと対策
- ○パフォーマンスの最適化のヒント
●Objective-Cのセマフォのカスタマイズ方法
- ○サンプルコード6：カスタムセマフォの作成方法
- ○サンプルコード7：セマフォの動的な調整
まとめ

はじめに

Objective-Cでのプログラミングを学ぶ中で、マルチスレッドや同期処理において重要な役割を果たすのが「セマフォ」です。

この記事では、Objective-Cでのセマフォの基本的な使い方から応用、さらに注意点やカスタマイズ方法までを10のステップで解説します。

特に初心者の方や、セマフォの概念が新しい方を対象に、サンプルコードを交えながらわかりやすく説明していきます。

●Objective-Cとは

Objective-Cは、C言語にオブジェクト指向の機能を追加したプログラミング言語です。

AppleのiOSやmacOSのアプリケーション開発に広く用いられており、その特徴的な文法や機能によって多くの開発者に支持されています。

○Objective-Cの特徴

Objective-Cは次のような特徴を持っています。

オブジェクト指向：クラスやインスタンス、メッセージパッシングといったオブジェクト指向の主要な概念をサポートしています。
動的型付け：変数の型が実行時に決定される特徴を持っており、これによって柔軟なコーディングが可能です。
カテゴリ：既存のクラスに新しいメソッドを追加する機能。これにより、ライブラリの拡張やカスタマイズが容易になります。
プロトコル：インターフェースの定義を別途行うことができ、異なるクラス間での共通の動作を約束することができます。

○Objective-Cでよく使用される概念

Objective-Cで頻繁に用いられる主な概念として次のようなものがあります。

メッセージパッシング：Objective-Cの中核となる概念で、オブジェクト同士がメッセージをやり取りすることで動作します。
プロパティ：オブジェクトの属性を外部からアクセスするための仕組み。属性の読み取りや書き込みを制御することができます。
デリゲート：あるオブジェクトの動作を外部のオブジェクトが代わりに実行する概念。特定のイベント時の処理をカスタマイズする際などに使用されます。
ブロック：C言語の関数ポインタの進化形で、コードの断片を変数として扱うことができます。非同期処理やコールバックの際に活用されることが多いです。

●セマフォとは

セマフォは、複数のスレッドやプロセスが同時に特定のリソースやコードをアクセスすることを制御するための同期プリミティブの一つです。

これは、複数のタスクが同じリソースに同時にアクセスすると、データの破損や不整合が発生するリスクがあるため、そのようなアクセスを適切に制御する必要があります。

Objective-Cの開発においても、複数のスレッドでのリソースのアクセス制御や、非同期処理の同期化にセマフォが活用されます。

Objective-Cでのセマフォの利用は、多くの場合、Foundationフレームワークの一部であるNSOperationQueueや、GCD(Grand Central Dispatch)と組み合わせて使用されることが多いです。

○セマフォの役割と基本的な概念

セマフォは、基本的にカウンタとしての機能を持っています。

このカウンタの値によって、同時にアクセス可能なスレッドの数を制御します。

例えば、セマフォのカウンタが2の場合、2つのスレッドが同時にアクセス可能であり、それ以上のスレッドは待機状態となります。

セマフォのカウンタは、スレッドがリソースにアクセスする際にデクリメント（減少）し、リソースの使用が終わった際にインクリメント（増加）されます。

これにより、指定された同時アクセス数を常に保つことができます。

○セマフォの種類

セマフォには大きく分けて2つの種類があります。

一つは「バイナリセマフォ」と呼ばれるもので、カウンタの値が0か1のみのセマフォです。

このタイプのセマフォは、排他制御（ミューテックスとも呼ばれる）の一形態として使用されることが多いです。

もう一つは「カウンティングセマフォ」と呼ばれるもので、カウンタの最大値が1以上のセマフォです。

このタイプのセマフォは、同時に複数のスレッドがリソースにアクセスすることを許容する場面で使用されることが多いです。

Objective-Cにおいては、GCDのdispatch_semaphore_tを用いてセマフォを実装することができます。

GCDはObjective-Cの強力な並列処理のためのライブラリであり、非常に効率的にマルチスレッドプログラミングを行うことができます。

●Objective-Cでのセマフォの基本的な使い方

Objective-Cにおけるセマフォは、多くの並行処理で非常に役立つツールです。

特に、複数のスレッドやタスクが特定のリソースに同時にアクセスする際に、そのアクセスを調整するために使用されます。

ここでは、Objective-Cでセマフォをどのように使用するか、初心者の方が理解しやすいようにステップバイステップで解説します。

○サンプルコード1：セマフォの基本的な使用方法

Objective-Cのセマフォの基本的な使用方法を見ていきましょう。

このコードでは、dispatch_semaphore_tを使ってセマフォを宣言し、その後dispatch_semaphore_waitとdispatch_semaphore_signalでセマフォを操作するコードを表しています。

この例では、セマフォを使って特定のリソースへのアクセスを制御しています。

// セマフォの宣言と初期化
dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);

// リソースへのアクセスを試みる
if (dispatch_semaphore_wait(semaphore, DISPATCH_TIME_NOW) != 0) {
    // リソースが使用中であれば、こちらの処理が実行されます。
    NSLog(@"リソース使用中");
} else {
    // リソースを使用する処理
    NSLog(@"リソース使用開始");

    // リソースの使用が完了したら、セマフォをシグナル状態に戻す
    dispatch_semaphore_signal(semaphore);
}

このコードを実行すると、”リソース使用開始”と表示され、リソースの使用が終わった後にセマフォのカウントが1に増加します。

もし他のスレッドやタスクがこのリソースを使用中であれば、”リソース使用中”と表示されます。

○サンプルコード2：セマフォを使った同期処理

セマフォは、非同期タスクの同期を取る際にも使用されることが多いです。

このコードでは、dispatch_asyncを使って非同期にタスクを実行しつつ、セマフォを用いてそのタスクの終了を待つコードを表しています。

この例では、非同期タスクが完了するまでの待機と、その後の処理を行っています。

dispatch_semaphore_t syncSemaphore = dispatch_semaphore_create(0);

// 非同期タスクの実行
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    // 何らかの処理
    NSLog(@"非同期タスク実行中");

    // タスクが終了したら、セマフォをシグナル状態にする
    dispatch_semaphore_signal(syncSemaphore);
});

// セマフォを使用して、非同期タスクの終了を待つ
dispatch_semaphore_wait(syncSemaphore, DISPATCH_TIME_FOREVER);
NSLog(@"非同期タスク終了");

このコードを実行すると、まず”非同期タスク実行中”と表示され、その後非同期タスクが終了したことを表す”非同期タスク終了”が表示されます。

●Objective-Cでのセマフォの応用例

セマフォは、並行処理やマルチスレッド環境でのリソースやタスクの同期を助ける重要な手段となります。

Objective-Cにおいても、セマフォは非常に役立つツールです。

ここでは、Objective-Cでのセマフォの応用例に焦点を当て、具体的なサンプルコードを交えながらその利用方法を詳しく解説していきます。

○サンプルコード3：複数のタスクを制御する

このコードでは、セマフォを利用して複数のタスクを制御する方法を表しています。

この例では、3つのタスクを同時に実行し、それぞれが完了するのを待ってから次の処理を進める構造を実現しています。

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // セマフォを作成。最初の値を3に設定。
        dispatch_semaphore_t semaphore = dispatch_semaphore_create(3);

        for (int i = 0; i < 3; i++) {
            dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
                NSLog(@"タスク%d開始", i + 1);
                sleep(2);  // 2秒待機
                NSLog(@"タスク%d完了", i + 1);

                // セマフォのカウントアップ
                dispatch_semaphore_signal(semaphore);
            });

            // セマフォのカウントダウン。0になるまで待機。
            dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        }
    }
    return 0;
}

このコードを実行すると、3つのタスクが同時に開始され、それぞれが完了するたびにログが出力されます。

○サンプルコード4：セマフォを使ったリソース管理

セマフォを使ってリソースのアクセスを制御する方法を紹介します。

この例では、複数のスレッドから同一のリソースへのアクセスを同期しています。

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // セマフォを作成。リソースの初期数を1とする。
        dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
        __block int resource = 0;

        for (int i = 0; i < 5; i++) {
            dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
                // セマフォのカウントダウン。0になるまで待機。
                dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

                resource += 1;
                NSLog(@"リソースの現在の値：%d", resource);

                // セマフォのカウントアップ
                dispatch_semaphore_signal(semaphore);
            });
        }
    }
    return 0;
}

このコードを実行すると、リソースの値が順番に増加することが確認できます。

セマフォを利用することで、リソースへの同時アクセスを防いでいます。

○サンプルコード5：セマフォを用いた非同期処理の同期化

セマフォを使って非同期処理を同期的に実行する方法を紹介します。

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

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);

        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            sleep(3);  // 3秒待機
            NSLog(@"非同期タスク完了");

            // セマフォのカウントアップ
            dispatch_semaphore_signal(semaphore);
        });

        NSLog(@"非同期タスクを待機中...");
        // セマフォのカウントダウン。0になるまで待機。
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        NSLog(@"非同期タスクが完了しました");
    }
    return 0;
}

このコードを実行すると、非同期タスクの完了をメインスレッドで待機し、その後の処理を進めることができます。

●セマフォを使う際の注意点と対処法

セマフォはマルチスレッド環境でのリソースアクセスを制御するための強力なツールです。

Objective-Cでの使用時には、いくつかの注意点と対処法が必要となります。

ここでは、セマフォの効果的な使用方法と、それに関連するトラブルを避けるためのヒントを詳しく解説します。

○デッドロックのリスクと対策

セマフォを使用する際、最も注意すべき問題はデッドロックです。

デッドロックは、2つ以上のスレッドがお互いに必要なリソースを持っていて、どちらも進行できない状態を指します。

これは、セマフォの取得と解放の順序によって引き起こされることがあります。

例えば、次のコードを考えてみましょう。

// スレッドA
dispatch_semaphore_t semaphoreA = dispatch_semaphore_create(1);
dispatch_semaphore_t semaphoreB = dispatch_semaphore_create(1);

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    dispatch_semaphore_wait(semaphoreA, DISPATCH_TIME_FOREVER);
    // ... 何らかの処理 ...
    dispatch_semaphore_wait(semaphoreB, DISPATCH_TIME_FOREVER);
    dispatch_semaphore_signal(semaphoreA);
    dispatch_semaphore_signal(semaphoreB);
});

// スレッドB
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    dispatch_semaphore_wait(semaphoreB, DISPATCH_TIME_FOREVER);
    // ... 何らかの処理 ...
    dispatch_semaphore_wait(semaphoreA, DISPATCH_TIME_FOREVER);
    dispatch_semaphore_signal(semaphoreB);
    dispatch_semaphore_signal(semaphoreA);
});

このコードでは、スレッドAとスレッドBが、semaphoreAとsemaphoreBの取得順序が異なるため、デッドロックのリスクが生じます。

これを解消するためには、セマフォの取得順序を統一することが一つの対策となります。

対策としては次のようにコードを変更することで、デッドロックを回避できます。

// スレッドAとスレッドBでセマフォの取得順序を統一
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    dispatch_semaphore_wait(semaphoreA, DISPATCH_TIME_FOREVER);
    dispatch_semaphore_wait(semaphoreB, DISPATCH_TIME_FOREVER);
    // ... 何らかの処理 ...
    dispatch_semaphore_signal(semaphoreA);
    dispatch_semaphore_signal(semaphoreB);
});

また、デッドロックのリスクを最小限にするために、セマフォの取得タイムアウトを設定することも考慮すると良いでしょう。

○パフォーマンスの最適化のヒント

セマフォの使用はリソースの制御に有効ですが、過度に使用するとパフォーマンスに影響を及ぼす可能性があります。

特に、頻繁にセマフォを取得・解放する場面では、スレッドの切り替えに伴うオーバーヘッドが生じやすくなります。

このような場合、次の方法でパフォーマンスを最適化することが考えられます。

セマフォは必要な場面でのみ使用し、それ以外の場面では避けるようにする。
セマフォの取得頻度を低減することで、スレッドの切り替えに伴うオーバーヘッドを減少させることができる。

例えば、一度の処理で大量のデータを扱う場合は、その処理全体をセマフォで囲むようにすることで、セマフォの取得・解放の回数を減らすことができます。

セマフォの使用は強力なツールですが、正しく使わないと逆にパフォーマンスの低下やデッドロックといった問題を引き起こす可能性があります。

注意深く、そして効果的に利用することが重要です。

●Objective-Cのセマフォのカスタマイズ方法

セマフォは同時アクセス制御のための強力なツールですが、Objective-Cでのカスタマイズも可能です。

特定の状況やニーズに合わせて、セマフォの動作を調整することが求められる場合があります。

ここでは、Objective-Cでのセマフォのカスタマイズ方法について詳しく解説します。

○サンプルコード6：カスタムセマフォの作成方法

セマフォは、基本的には同時にアクセスできるリソースの数を制御するためのものです。

しかし、特定の条件下での動作をカスタマイズしたい場合があります。

このコードでは、カスタムセマフォを作成して、特定の条件下でセマフォの動作をカスタマイズする方法を表しています。

この例では、特定のカウント数に達した時に、追加のアクションを実行するカスタムセマフォを作成しています。

#import <Foundation/Foundation.h>

@interface CustomSemaphore : NSObject {
    dispatch_semaphore_t _semaphore;
    int _customCount;
}

- (instancetype)initWithCustomCount:(int)count;
- (BOOL)wait;
- (void)signal;

@end

@implementation CustomSemaphore

- (instancetype)initWithCustomCount:(int)count {
    if (self = [super init]) {
        _semaphore = dispatch_semaphore_create(0);
        _customCount = count;
    }
    return self;
}

- (BOOL)wait {
    if (dispatch_semaphore_wait(_semaphore, DISPATCH_TIME_NOW) != 0) {
        return NO;
    }
    _customCount--;
    if (_customCount == 0) {
        NSLog(@"カスタムカウントが0になりました。");
        // ここでカスタムのアクションを実行
    }
    return YES;
}

- (void)signal {
    dispatch_semaphore_signal(_semaphore);
}

@end

このカスタムセマフォでは、waitメソッドを呼び出す度にカスタムカウントがデクリメントされます。

そして、カスタムカウントが0になった時に、特定のアクションを実行します。

このアクションは、例としてログ出力を行っていますが、実際には任意の処理を行うことができます。

このカスタムセマフォを使用すれば、通常のセマフォと同様に同時アクセス制御を行いながら、特定の条件下で追加の処理を実行することが可能となります。

次に、このカスタムセマフォを使用した場合の動作を表します。

例えば、カスタムカウントが3で初期化されたセマフォの場合、3回waitメソッドが呼ばれた後、カスタムのアクションが実行されます。

CustomSemaphore *semaphore = [[CustomSemaphore alloc] initWithCustomCount:3];
[semaphore wait];
[semaphore wait];
[semaphore wait];

上記のコードを実行すると、「カスタムカウントが0になりました。」というログが出力されることが確認できます。

○サンプルコード7：セマフォの動的な調整

セマフォの動的な調整は、実行中のプログラムでセマフォの挙動を変更することを意味します。

例えば、リソースの可用性が変わった場合や、外部からの入力に応じてセマフォの動作を変更する必要がある場合にこの方法を利用します。

このコードでは、実行中のプログラムでセマフォのカウントを動的に変更する方法を表しています。

この例では、セマフォのカウントを増減させることで、同時にアクセスできるリソースの数を動的に変更しています。

#import <Foundation/Foundation.h>

@interface DynamicSemaphore : NSObject {
    dispatch_semaphore_t _semaphore;
}

- (instancetype)initWithCount:(long)count;
- (BOOL)wait;
- (void)signal;
- (void)increaseCount:(long)count;
- (void)decreaseCount:(long)count;

@end

@implementation DynamicSemaphore

- (instancetype)initWithCount:(long)count {
    if (self = [super init]) {
        _semaphore = dispatch_semaphore_create(count);
    }
    return self;
}

- (BOOL)wait {
    return dispatch_semaphore_wait(_semaphore, DISPATCH_TIME_NOW) == 0;
}

- (void)signal {
    dispatch_semaphore_signal(_semaphore);
}

- (void)increaseCount:(long)count {
    for (long i = 0; i < count; i++) {
        dispatch_semaphore_signal(_semaphore);
    }
}

- (void)decreaseCount:(long)count {
    for (long i = 0; i < count; i++) {
        dispatch_semaphore_wait(_semaphore, DISPATCH_TIME_FOREVER);
    }
}

@end

DynamicSemaphoreは、セマフォのカウントを増やすincreaseCount:メソッドと、カウントを減らすdecreaseCount:メソッドを提供しています。

これにより、実行中のプログラムでセマフォのカウントを動的に変更することができます。

例えば、次のようにして、初期カウントが2のセマフォを作成し、後からカウントを増減させることができます。

DynamicSemaphore *semaphore = [[DynamicSemaphore alloc] initWithCount:2];
[semaphore wait];
[semaphore increaseCount:1];
[semaphore wait];
[semaphore decreaseCount:1];
[semaphore wait];

このコードを実行すると、最初の2回のwaitはすぐに成功しますが、3回目のwaitはセマフォのカウントが0になっているため、待機状態となります。