我只是在晚上花了一些时间来研究 GCD，尤其是 dispatch_semaphore_t，因为我从未使用过它。从来不需要。

所以我写了下面的作为测试:

- (void)viewDidLoad
{
        UIView *firstView = [[UIView alloc] initWithFrame:(CGRect){{0, 0}, self.view.frame.size.width/4, self.view.frame.size.width/5}];
        firstView.backgroundColor = [UIColor purpleColor];
        [self.view addSubview:firstView];


        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^
        {
            for (long i = 0; i < 1000; i++)
            {
                sleep(5);
                dispatch_async(dispatch_get_main_queue(), ^
                {
                    firstView.layer.opacity = ((i%2) ? 0: 1);
                });
            }
        });

        dispatch_queue_t queue1 = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
        dispatch_group_t group1 = dispatch_group_create();

        dispatch_group_async(group1, queue1, ^
        {
             sleep(3);
             NSLog(@"dispatch group 1");
        });
        
        dispatch_group_notify(group1, queue1, ^
        {
            NSLog(@"dispatch notify 1");
        });

        dispatch_async(myQueue, ^
        {
            for(int z = 0; z < 10; z++)
            {
                NSLog(@"%i", z);
                sleep(1);
            }
            dispatch_semaphore_signal(mySemaphore);
       });

       dispatch_semaphore_wait(mySemaphore, DISPATCH_TIME_FOREVER);
       NSLog(@"Loop is Done");
}

如果我运行上面的代码，输出将是:

0

1

2

dispatch group 1

dispatch notify 1

3

4

5

6

7

8

9

Loop is Done

在上面之后，firstView 出现在屏幕上(在 semaphore 之前整个屏幕是黑色的)，最后执行:

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^
{
    for (long i = 0; i < 1000; i++)
    {
        sleep(5);
        dispatch_async(dispatch_get_main_queue(), ^
        {
            firstView.layer.opacity = ((i%2) ? 0: 1);
        });
    }
});

仅在信号量完成后循环运行时交替不透明度。

1.)

所以，似乎我必须等到 dispatch_semaphore 完成它的工作才能发生任何 UI 事情。

但是:

如上面的输出所示(即 1、2、3、....)，dispatch_group_t 似乎与 dispatch_semaphore 同时运行。

???

2.)

如果我将上面的 for 循环 更改为使用:dispatch_async(dispatch_get_main_queue(), ^

代替:

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^,

即使在 semaphore 完成后，屏幕上也不会显示任何内容。

怎么会？？？

3.)

此外，如果我将 semaphore 更改为以下内容，而不是像上面那样使用全局队列:

dispatch_async(dispatch_get_main_queue(), ^
{
    for(int z = 0; z < 10; z++)
    {
        NSLog(@"%i", z);
        sleep(1);
    }
    dispatch_semaphore_signal(mySemaphore);
});

只有 dispatch_group 发生；除了上面的 for 循环，包括 UI 之外，没有其他的地方/被执行。什么都没有。

4.)

所以除了我在上面指出的之外，我还能做些什么，以使 semaphore 不阻塞我的 UI 和我的其他进程，让我的 UI 和其他进程做他们的事情？

并且如上所述，为什么将 semaphore 的队列类型从 global 更改为 main 会导致屏幕上不显示任何内容，甚至循环也不会执行，除了 dispatch_group?

5.)

如果我将 semaphore 更改为:

dispatch_semaphore_t mySemaphore = dispatch_semaphore_create(1); 

//1 instead of 0 (zero)

一切(即 for 循环和 UI)立即运行并且 NSLog(@"Loop is Done"); 也立即显示，这告诉我信号量没有在这里等待:

dispatch_semaphore_wait(mySemaphore, DISPATCH_TIME_FOREVER);
NSLog(@"Loop is Done");

???

我花了整个晚上试图解决这个问题，但无济于事。 我希望有丰富 GCD 知识的人能在这方面启发我。

最佳答案

首先要做的事情:作为一般规则，永远不要阻塞主队列。这条关于不阻塞主队列的规则适用于 dispatch_semaphore_wait() 和 sleep()(以及任何同步调度、任何组等待等)。您永远不应该在主队列上执行任何这些可能阻塞的调用。如果您遵循此规则，您的 UI 将永远不会变得无响应。

您的代码示例和后续问题似乎暗示了组和信号量之间的混淆。调度组是一种跟踪一组已调度 block 的方法。但是你在这里没有利用调度组的特性，所以我可能建议将它们从讨论中删除，因为它与关于信号量的讨论无关。

另一方面，调度信号量只是一个线程向另一个正在等待信号的线程发送信号的机制。不用说，您已经创建了一个信号量并通过该信号量发送信号这一事实不会影响您的任何分派(dispatch)任务(无论是否分组)，除非相关代码恰好调用 dispatch_semaphore_wait .

最后，在您后来的一些示例中，您尝试让信号量发送多个信号或将初始计数更改为在创建信号量时提供。对于每个 signal，您通常需要一个相应的 wait。如果你有十个信号，你需要十个等待。

因此，让我们以一种您的主队列(以及 UI)永远不会被阻塞的方式来说明信号量。在这里，我们可以在两个独立并发运行的任务之间发送十个信号，让后者更新 UI:

dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);

// send 10 signals from one background thread

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0), ^{
    for (NSInteger i = 0; i < 10; i++) {
        NSLog(@"Sleeping %d", i);
        sleep(3);
        NSLog(@"Sending signal %d", i);
        dispatch_semaphore_signal(semaphore);
    }

    NSLog(@"Done signaling");
});

// and on another thread, wait for those 10 signals ...

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0), ^{
    for (NSInteger i = 0; i < 10; i++) {
        NSLog(@"Waiting for signal %d", i);
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        NSLog(@"Got signal %d", i);

        // if you want to update your UI, then dispatch that back to the main queue

        dispatch_async(dispatch_get_main_queue(), ^{
            // update your UI here
        });
    }

    NSLog(@"Done waiting");
});

不可否认，这不是一个非常有用的信号量示例，但它说明了您在理论上可以如何使用它们。在实践中，您很少需要使用信号量，因为对于大多数业务问题，还有其他更优雅的编码模式。如果您描述了您想要做什么，我们可以向您展示如何最好地实现它。

关于将非零值传递给 dispatch_semaphore_create 的示例，它用于控制对某些有限资源的访问。在此示例中，假设您有 100 个任务要运行，但您不希望在任何给定时间运行超过 5 个任务(例如，您正在使用网络连接(有限)，或者每个操作占用如此您希望避免在任何给定时间运行超过五个的内存)。然后你可以这样做:

// we only want five to run at any given time

dispatch_semaphore_t semaphore = dispatch_semaphore_create(5);

// send this to background queue, so that when we wait, it doesn't block main queue

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    for (NSInteger i = 0; i < 100; i++)
    {
        // wait until one of our five "slots" are available

        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

        // when it is, dispatch code to background queue

        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            NSLog(@"starting %d", i);
            // to simulate something slow happening in the background, we'll just sleep
            sleep(5);
            NSLog(@"Finishing %d", i);

            // when done, signal that this "slot" is free (please note, this is done
            // inside the dispatched block of code)

            dispatch_semaphore_signal(semaphore);
        });
    }
});

同样，这不是一个很好的信号量示例(在这种情况下，我通常会使用带有 maxConcurrentOperationCount 的 NSOperationQueue)，但它说明了一个示例为什么要为 dispatch_source_create 使用非零值。

您问了很多关于群组的问题。我认为组与您自己的信号量无关。例如，如果您想在所有任务完成后运行一段代码，您可能会使用一个组。所以这里是上述示例的变体，但使用 dispatch_group_notify 在该组中的所有其他任务完成时执行某些操作。

dispatch_queue_t     queue     = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); // or create your own concurrent queue
dispatch_semaphore_t semaphore = dispatch_semaphore_create(5);
dispatch_group_t     group     = dispatch_group_create();

// send this to background queue, so that when we wait, it doesn't block main queue

dispatch_async(queue, ^{
    for (NSInteger i = 0; i < 100; i++)
    {
        // wait until one of our five "slots" are available

        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

        // when it is, dispatch code to background queue

        dispatch_group_async(group, queue, ^{
            NSLog(@"starting %d", i);
            // to simulate something slow happening in the background, we'll just sleep
            sleep(5);
            NSLog(@"Finishing %d", i);
            dispatch_semaphore_signal(semaphore);
        });
    }

    dispatch_group_notify(group, queue, ^{
        NSLog(@"All done");
    });
});

关于ios - 无形的执行顺序(dispatch_semaphore_t、dispatch_group_async)以及它们与不同调度队列类型的结合使用，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/21371797/