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

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

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

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

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(@"非同期タスク終了");

#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;
}

#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;
}

#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;
}

// スレッド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でセマフォの取得順序を統一
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);
});

#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

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

#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 *semaphore = [[DynamicSemaphore alloc] initWithCount:2];
[semaphore wait];
[semaphore increaseCount:1];
[semaphore wait];
[semaphore decreaseCount:1];
[semaphore wait];