什么是信號量

信號量（semaphore）是操作系統(tǒng)用來解決并發(fā)中的互斥和同步問題的一種方法嵌言。
信號量對于允許多個線程并發(fā)訪問的資源嗅回，它是一個很好的選擇。一個初始值為N的信號量允許N個線程并發(fā)訪問摧茴。線程訪問資源時首先獲取信號量绵载，進行如下操作：
將信號量的值減1。如果信號量的值小于0苛白，則進入等待狀態(tài)娃豹，否則繼續(xù)執(zhí)行。訪問資源之后购裙，線程釋放信號量懂版，將信號量的值加1。如果信號量的值不小于1躏率，喚醒一個等待中的線程躯畴。

信號量的使用

//初始化信號量，初始值N = 2薇芝，表示最多只允許兩條線程同時獲得信號量
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(2);
    // 并發(fā)隊列
    dispatch_queue_t conQueue = dispatch_queue_create("com.hello-world.djx", DISPATCH_QUEUE_CONCURRENT);
    for (int i = 1; i <= 5; i++) {
        dispatch_async(conQueue, ^{
          // 線程執(zhí)行dispatch_semaphore_wait時蓬抄，會獲取當前信號量，將信號量值減一恩掷，如果信號量值小于0倡鲸，則等待dispatch_semaphore_signal喚醒線程；如果信號量值大于或等于0則開始執(zhí)行任務
            dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
            NSLog(@"開始任務：%d", i);
            sleep(i);
            NSLog(@"結(jié)束任務：%d", i);
            //線程執(zhí)行完任務之后調(diào)用dispatch_semaphore_signal黄娘，將信號量值加一峭状，如果此時信號量值大于0，說明沒有等待的線程逼争，直接返回优床，如果此時信號量值小于或等于0，表次此前信號量已用盡誓焦，可能有正等待的線程胆敞，這時候會試圖喚起等待的線程
            dispatch_semaphore_signal(semaphore);
        });
    }

打印結(jié)果：

2021-08-25 15:51:47.942058+0800 GCDDemo[31306:26034698] 開始任務：2
2021-08-25 15:51:47.942087+0800 GCDDemo[31306:26034700] 開始任務：1
2021-08-25 15:51:48.945177+0800 GCDDemo[31306:26034700] 結(jié)束任務：1
2021-08-25 15:51:48.945402+0800 GCDDemo[31306:26034699] 開始任務：4
2021-08-25 15:51:49.944143+0800 GCDDemo[31306:26034698] 結(jié)束任務：2
2021-08-25 15:51:49.944354+0800 GCDDemo[31306:26034697] 開始任務：3
2021-08-25 15:51:52.947185+0800 GCDDemo[31306:26034699] 結(jié)束任務：4
2021-08-25 15:51:52.947173+0800 GCDDemo[31306:26034697] 結(jié)束任務：3
2021-08-25 15:51:52.947391+0800 GCDDemo[31306:26034696] 開始任務：5
2021-08-25 15:51:57.947824+0800 GCDDemo[31306:26034696] 結(jié)束任務：5

可以看出只能同時執(zhí)行兩個任務，一個任務結(jié)束之后才能喚醒其他等待的線程繼續(xù)執(zhí)行杂伟。信號量在這里起到控制隊列并發(fā)數(shù)的作用移层。其實這里的初始值如果改成1的話，信號量就相當于互斥鎖的作用了赫粥。

信號量的底層原理

dispatch_semaphore_create源碼解讀

這是創(chuàng)建信號量并初始化信號量的函數(shù)观话，參數(shù)value就是信號量的值。

dispatch_semaphore_t
dispatch_semaphore_create(long value)
{
    dispatch_semaphore_t dsema;

    // If the internal value is negative, then the absolute of the value is
    // equal to the number of waiting threads. Therefore it is bogus to
    // initialize the semaphore with a negative value.
    if (value < 0) {
        return DISPATCH_BAD_INPUT;
    }

    dsema = _dispatch_object_alloc(DISPATCH_VTABLE(semaphore),
            sizeof(struct dispatch_semaphore_s));
    dsema->do_next = DISPATCH_OBJECT_LISTLESS;
    dsema->do_targetq = _dispatch_get_default_queue(false);
    dsema->dsema_value = value;
    _dispatch_sema4_init(&dsema->dsema_sema, _DSEMA4_POLICY_FIFO);
    dsema->dsema_orig = value;
    return dsema;
}

DISPATCH_VTABLE這里可以獲取到信號量的類信息越平，通過_dispatch_object_alloc創(chuàng)建一個信號量频蛔。value值被保留到屬性dsema_value和dsema_orig中（為什么這里會有兩個變量來接收value灵迫？請看后面的dispose方法），后面的調(diào)用的dispatch_semaphore_wait和dispatch_semaphore_signal都會對dsema_value進行操作晦溪。_dispatch_sema4_init初始化一個信號瀑粥。

dispatch_semaphore_wait源碼解讀

long
dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout)
{
    long value = os_atomic_dec2o(dsema, dsema_value, acquire);
    if (likely(value >= 0)) {
        return 0;
    }
    return _dispatch_semaphore_wait_slow(dsema, timeout);
}

os_atomic_dec2o：os_atomic_dec2o->os_atomic_sub2o->os_atomic_sub->_os_atomic_c11_op((p), (v), m, sub, -)->atomic_fetch_sub_explicit
這里通過函數(shù)os_atomic_dec2o，最終調(diào)用atomic_fetch_sub_explicit對value進行減1的原子操作三圆，然后返回當前信號量value狞换。判斷如果value大于0，說當前線程可以正常訪問嫌术，直接返回0表次正常哀澈；反之，線程會調(diào)用函數(shù)_dispatch_semaphore_wait_slow進入等待被喚醒度气。

static long
_dispatch_semaphore_wait_slow(dispatch_semaphore_t dsema,
        dispatch_time_t timeout)
{
    long orig;

    _dispatch_sema4_create(&dsema->dsema_sema, _DSEMA4_POLICY_FIFO);
    switch (timeout) {
    default:
        if (!_dispatch_sema4_timedwait(&dsema->dsema_sema, timeout)) {
            break;
        }
        // Fall through and try to undo what the fast path did to
        // dsema->dsema_value
    case DISPATCH_TIME_NOW:
        orig = dsema->dsema_value;
        while (orig < 0) {
            if (os_atomic_cmpxchgvw2o(dsema, dsema_value, orig, orig + 1,
                    &orig, relaxed)) {
                return _DSEMA4_TIMEOUT();
            }
        }
        // Another thread called semaphore_signal().
        // Fall through and drain the wakeup.
    case DISPATCH_TIME_FOREVER:
        _dispatch_sema4_wait(&dsema->dsema_sema);
        break;
    }
    return 0;
}

這時候會根據(jù)timeout參數(shù)設定的時間來處理割按。如果timeout傳的是DISPATCH_TIME_NOW，則表示不等待磷籍，這時候會再次嘗試獲取信號量适荣，如果信號量此時已然小于0，則返回超時提醒院领；如果傳入的是DISPATCH_TIME_FOREVER弛矛，表示會一直等待被喚醒，這時候就調(diào)用函數(shù)_dispatch_sema4_wait進行等待比然；如果是給定的一段時間丈氓，走default邏輯，調(diào)用函數(shù)_dispatch_sema4_timedwait進入計時等待：

bool
_dispatch_sema4_timedwait(_dispatch_sema4_t *sema, dispatch_time_t timeout)
{
    struct timespec _timeout;
    int ret;

    do {
        uint64_t nsec = _dispatch_time_nanoseconds_since_epoch(timeout);
        _timeout.tv_sec = (__typeof__(_timeout.tv_sec))(nsec / NSEC_PER_SEC);
        _timeout.tv_nsec = (__typeof__(_timeout.tv_nsec))(nsec % NSEC_PER_SEC);
        ret = sem_timedwait(sema, &_timeout);
    } while (unlikely(ret == -1 && errno == EINTR));

    if (ret == -1 && errno == ETIMEDOUT) {
        return true;
    }
    DISPATCH_SEMAPHORE_VERIFY_RET(ret);
    return false;
}

等線程被喚醒之后返回執(zhí)行代碼强法，否則知道時間耗盡返回超時提醒万俗。

dispatch_semaphore_signal源碼解讀

long
dispatch_semaphore_signal(dispatch_semaphore_t dsema)
{
    long value = os_atomic_inc2o(dsema, dsema_value, release);
    if (likely(value > 0)) {
        return 0;
    }
    if (unlikely(value == LONG_MIN)) {
        DISPATCH_CLIENT_CRASH(value,
                "Unbalanced call to dispatch_semaphore_signal()");
    }
    return _dispatch_semaphore_signal_slow(dsema);
}

os_atomic_inc2o：os_atomic_inc2o->os_atomic_add2o->os_atomic_add->_os_atomic_c11_op((p), (v), m, add, +)->atomic_fetch_add_explicit
通過函數(shù)os_atomic_inc2o釋放資源（release），同時對信號量加1饮怯，然后返回加1之后的結(jié)果value闰歪。判斷value大于0，直接返回0蓖墅；如果value小于或等于0库倘，說明加1之前的值小于0，可能存在等待的線程论矾，然后調(diào)用函數(shù)_dispatch_semaphore_signal_slow教翩，發(fā)送一個信號去喚起等待的線程。

long
_dispatch_semaphore_signal_slow(dispatch_semaphore_t dsema)
{
    _dispatch_sema4_create(&dsema->dsema_sema, _DSEMA4_POLICY_FIFO);
    _dispatch_sema4_signal(&dsema->dsema_sema, 1);
    return 1;
}

_dispatch_semaphore_dispose源碼解讀

_dispatch_semaphore_dispose實際上就是信號量銷毀時調(diào)用的方法：

void
_dispatch_semaphore_dispose(dispatch_object_t dou,
        DISPATCH_UNUSED bool *allow_free)
{
    dispatch_semaphore_t dsema = dou._dsema;

    if (dsema->dsema_value < dsema->dsema_orig) {
        DISPATCH_CLIENT_CRASH(dsema->dsema_orig - dsema->dsema_value,
                "Semaphore object deallocated while in use");
    }

    _dispatch_sema4_dispose(&dsema->dsema_sema, _DSEMA4_POLICY_FIFO);
}

前面我們提到贪壳，在創(chuàng)建信號量時有兩個屬性dsema_value和dsema_orig接收value饱亿。其實dsema_orig是用來保留初始值，dsema_value在信號量使用過程中不斷變化。等到dispose時路捧，會判斷dsema_value和dsema_orig是否相等，如果dsema_value小于初始值dsema_orig传黄，那么系統(tǒng)就會認為信號量還在使用中杰扫，此時銷毀就會發(fā)生crash。所以這是為什么信號量的dispatch_semaphore_signal和dispatch_semaphore_wait要成對使用的原因膘掰。