1
/*!
2
 * @function dispatch_semaphore_create
3
 *
4
 * @abstract
5
 * 用初始值创建新的计数信号量
6
 *
7
 * @discussion
8
 * 当两个线程需要协调时，为该值传递0是有用的 完成某一特定事件。
9
 * 传递一个大于零的值 用于管理有限的资源池，其中池大小相等 的价值
10
 *
11
 * @param value
12
 * 信号量的起始值。传递一个小于零的值 导致返回NULL。
13
 *
14
 *
15
 * @result
16
 * 新创建的信号量，如果失败则为NULL
17
 */
18
API_AVAILABLE(macos(10.6), ios(4.0))
19
DISPATCH_EXPORT DISPATCH_MALLOC DISPATCH_RETURNS_RETAINED DISPATCH_WARN_RESULT
20
DISPATCH_NOTHROW
21
dispatch_semaphore_t
22
dispatch_semaphore_create(intptr_t value);

1
/*!
2

3
 * @function dispatch_semaphore_signal
4
 *
5
 * @abstract
6
 * Signal (increment) a semaphore.
7
 *
8
 * @discussion
9
 * 增加计数信号量。如果之前的值小于零
10
 * 这个函数在返回之前唤醒一个等待线程
11
 *
12
 * @param dsema The counting semaphore.
13
 * 在这个参数中传递NULL的结果是未定义的
14
 *
15
 * @result
16
 * 如果线程被唤醒，这个函数返回非零值。否则,返回零
17
 *
18
 */
19

20

21
intptr_t
22
dispatch_semaphore_signal(dispatch_semaphore_t dsema)
23
{
24
    // +1 的操作
25
    long value = os_atomic_inc2o(dsema, dsema_value, release);
26
    if (likely(value > 0)) {
27
  return 0;
28
    }
29

30
    // wait 操作过多 和signal信号不平衡 抛出异常
31
    if (unlikely(value == LONG_MIN)) {
32
  DISPATCH_CLIENT_CRASH(value,
33
        "Unbalanced call to dispatch_semaphore_signal()");
34
    }
35
    //因为是基于pthread下层的封装，为了避免下层的异常，这里做异常处理
36
    return _dispatch_semaphore_signal_slow(dsema);
37
}

1
/*!
2
 * @function dispatch_semaphore_wait
3
 *
4
 * @abstract
5
 * 等待(递减)信号量
6
 *
7
 * @discussion
8
 * 递减计数信号量。如果结果值小于零，
9
 * 这个函数在返回之前等待一个信号出现。
10
 *
11
 * @param dsema
12
 * 信号量。在这个参数中传递NULL的结果是未定义的
13
 *
14
 * @param timeout
15
 * 何时超时(参见dispatch_time)。为了方便，
16
 * 有 DISPATCH_TIME_NOW和DISPATCH_TIME_FOREVER常量。
17
 *
18
 * @result
19
 * 成功时返回零，如果超时则返回非零
20
 */
21

22
intptr_t
23
dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout)
24
{
25
    // -1 操作
26
    long value = os_atomic_dec2o(dsema, dsema_value, acquire);
27
    if (likely(value >= 0)) {
28
        return 0;
29
    }
30
    return _dispatch_semaphore_wait_slow(dsema, timeout);
31
}

1
static intptr_t
2
_dispatch_semaphore_wait_slow(dispatch_semaphore_t dsema,
3
    dispatch_time_t timeout)
4
{
5
    long orig;
6

7
    _dispatch_sema4_create(&dsema->dsema_sema, _DSEMA4_POLICY_FIFO);
8

9
    //判断timeout
10
    switch (timeout) {
11
    default:
12
  if (!_dispatch_sema4_timedwait(&dsema->dsema_sema, timeout)) {
13
    break;
14
  }
15
  // Fall through and try to undo what the fast path did to
16
  // dsema->dsema_value
17
        case DISPATCH_TIME_NOW:
18
            orig = dsema->dsema_value;
19
            while (orig < 0) {
20
    if (os_atomic_cmpxchgv2o(dsema, dsema_value, orig, orig + 1,
21
          &orig, relaxed)) {
22
                    // 处理超时
23
                    return _DSEMA4_TIMEOUT();
24
    }
25
            }
26
            // Another thread called semaphore_signal().
27
            // Fall through and drain the wakeup.
28
  case DISPATCH_TIME_FOREVER:
29
            //等待操作
30
            _dispatch_sema4_wait(&dsema->dsema_sema);
31
            break;
32
  }
33
  return 0;
34
}

1
void
2
_dispatch_sema4_wait(_dispatch_sema4_t *sema)
3
{
4
  int ret = 0;
5
  do {
6
    ret = sem_wait(sema);
7
  } while (ret == -1 && errno == EINTR);
8
  DISPATCH_SEMAPHORE_VERIFY_RET(ret);
9
}