10

为什么我会陷入僵局?

- (void)foo
{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{

        [self foo];

    });

    // whatever...
}

我希望foo在第一次调用时被执行两次。

4

2 回答 2

25

现有的答案都不是很准确(一个是完全错误的,另一个有点误导并遗漏了一些关键细节)。首先,让我们直接进入源代码

void
dispatch_once_f(dispatch_once_t *val, void *ctxt, dispatch_function_t func)
{
    struct _dispatch_once_waiter_s * volatile *vval =
            (struct _dispatch_once_waiter_s**)val;
    struct _dispatch_once_waiter_s dow = { NULL, 0 };
    struct _dispatch_once_waiter_s *tail, *tmp;
    _dispatch_thread_semaphore_t sema;

    if (dispatch_atomic_cmpxchg(vval, NULL, &dow)) {
        dispatch_atomic_acquire_barrier();
        _dispatch_client_callout(ctxt, func);

        dispatch_atomic_maximally_synchronizing_barrier();
        //dispatch_atomic_release_barrier(); // assumed contained in above
        tmp = dispatch_atomic_xchg(vval, DISPATCH_ONCE_DONE);
        tail = &dow;
        while (tail != tmp) {
            while (!tmp->dow_next) {
                _dispatch_hardware_pause();
            }
            sema = tmp->dow_sema;
            tmp = (struct _dispatch_once_waiter_s*)tmp->dow_next;
            _dispatch_thread_semaphore_signal(sema);
        }
    } else {
        dow.dow_sema = _dispatch_get_thread_semaphore();
        for (;;) {
            tmp = *vval;
            if (tmp == DISPATCH_ONCE_DONE) {
                break;
            }
            dispatch_atomic_store_barrier();
            if (dispatch_atomic_cmpxchg(vval, tmp, &dow)) {
                dow.dow_next = tmp;
                _dispatch_thread_semaphore_wait(dow.dow_sema);
            }
        }
        _dispatch_put_thread_semaphore(dow.dow_sema);
    }
}

所以真正发生的是,与其他答案相反,onceToken从其初始状态更改NULL为指向第一个调用者堆栈上的地址&dow(调用此调用者 1)。这发生调用块之前。如果在块完成之前有更多的调用者到达,他们将被添加到等待者的链表中,其头部包含在onceToken块完成之前(称为调用者 2..N)。添加到此列表后,调用者 2..N 等待调用者 1 的信号量来完成块的执行,此时调用者 1 将遍历链表,为每个调用者 2..N 发送一次信号量。在那个走的开始,onceToken改成了DISPATCH_ONCE_DONE(它被方便地定义为一个永远不会是有效指针的值,因此永远不会成为阻塞调用者链表的头部。)将其更改DISPATCH_ONCE_DONE为使得后续调用者便宜(对于其余的调用者)进程的生命周期)来检查完成状态。

所以在你的情况下,发生了什么是这样的:

  • 第一次调用-foo,onceToken是 nil (通过保证将静态变量初始化为 0 来保证这一点),并被原子地更改为服务员链表的头部。
  • 当您-foo从块内部递归调用时,您的线程被认为是“第二个调用者”,并且存在于这个新的较低堆栈帧中的等待者结构被添加到列表中,然后您去等待信号量。
  • 这里的问题是这个信号量永远不会被发出信号,因为为了发出信号,你的块必须完成执行(在更高的堆栈帧中),现在由于死锁而无法发生。

所以,简而言之,是的,你陷入了僵局,这里的实际要点是,“不要尝试递归调用一个dispatch_once块。” 但问题绝对不是“无限递归”,而且标志绝对不仅仅是在块完成执行后更改 -在块执行之前更改它正是它知道让调用者 2..N 等待调用者 1完成。

于 2013-10-04T11:24:45.760 回答
2

您可以稍微更改代码,以便调用在块之外并且没有死锁,如下所示:

- (void)foo
{
    static dispatch_once_t onceToken;
    BOOL shouldRunTwice = NO;
    dispatch_once(&onceToken, ^{
        shouldRunTwice = YES;
    });
    if (shouldRunTwice) {
        [self foo];
    }
    // whatever...
}
于 2013-12-23T19:03:17.537 回答