iPhone - главный поток Grand Central Dispatch

Отправка блока в основную очередь обычно выполняется из фоновой очереди, чтобы сигнализировать о завершении некоторой фоновой обработки, например.

- (void)doCalculation
{
    //you can use any string instead "com.mycompany.myqueue"
    dispatch_queue_t backgroundQueue = dispatch_queue_create("com.mycompany.myqueue", 0);

    dispatch_async(backgroundQueue, ^{
        int result = <some really long calculation that takes seconds to complete>;

        dispatch_async(dispatch_get_main_queue(), ^{
            [self updateMyUIWithResult:result];
        });    
    });
}

В этом случае мы выполняем длительный расчет в фоновой очереди и должны обновить наш пользовательский интерфейс, когда расчет будет завершен. Обновление пользовательского интерфейса обычно должно выполняться из основной очереди, поэтому мы «сигнализируем» обратно в основную очередь, используя второй вложенный dispatch_async.

Вероятно, есть и другие примеры, когда вы можете захотеть отправить обратно в основную очередь, но обычно это делается таким образом, то есть вложенным из блока, отправляемого в фоновую очередь.

• фоновая обработка завершена -> обновить пользовательский интерфейс
• фрагмент данных, обрабатываемый в фоновой очереди -> сигнализировать основной очереди о запуске следующего фрагмента
• входящие сетевые данные в фоновой очереди -> сигнализировать основной очереди о прибытии сообщения
• и т. д. и т. д.

Что касается того, почему вы можете захотеть отправить отправку в основную очередь из основной очереди ... Ну, обычно вы этого не сделаете, хотя, возможно, вы могли бы сделать это, чтобы запланировать некоторую работу, которую нужно выполнить в следующий раз цикл выполнения.

Отправка блоков в основную очередь из основного потока может быть полезной. Это дает основной очереди возможность обрабатывать другие блоки, которые были поставлены в очередь, так что вы не просто блокируете выполнение всего остального.

Например, вы можете написать по существу однопоточный сервер, который, тем не менее, обрабатывает множество одновременных подключений. Пока отдельный блок в очереди не занимает слишком много времени, сервер остается реагировать на новые запросы.

Если ваша программа ничего не делает, а тратит всю свою жизнь, реагируя на события, это вполне естественно. Вы просто настраиваете свои обработчики событий для запуска в основной очереди, а затем вызываете dispatch_main (), и вам, возможно, вообще не нужно беспокоиться о безопасности потоков.

Надеюсь, я правильно понимаю ваш вопрос в том смысле, что вам интересно узнать о различиях между dispatch_async и dispatch_sync?

dispatch_async

асинхронно отправит блок в очередь. Это означает, что он отправит блок в очередь и не будет ждать его возврата, прежде чем продолжить выполнение оставшегося кода в вашем методе.

dispatch_sync

синхронно отправит блок в очередь. Это предотвратит выполнение оставшегося кода в методе до тех пор, пока выполнение блока не завершится.

Я в основном использовал dispatch_async для фоновой очереди, чтобы получить работу из основной очереди и воспользоваться всеми дополнительными ядрами, которые могут быть у устройства. Затем dispatch_async в основной поток, если мне нужно обновить пользовательский интерфейс.

Удачи

Одно место, где это полезно, - это действия пользовательского интерфейса, такие как установка счетчика перед длительной операцией:

- (void) handleDoSomethingButton{

    [mySpinner startAnimating];

    (do something lengthy)
    [mySpinner stopAnimating];
}

не будет работать, потому что вы блокируете основной поток во время своей длительной работы и не позволяете UIKit фактически запускать счетчик.

- (void) handleDoSomethingButton{
     [mySpinner startAnimating];

     dispatch_async (dispatch_get_main_queue(), ^{
          (do something lengthy)
          [mySpinner stopAnimating];
    });
}

вернет управление циклу выполнения, который запланирует обновление пользовательского интерфейса, запустит счетчик, а затем получит следующую вещь из очереди отправки, которая является вашей фактической обработкой. Когда ваша обработка завершена, вызывается остановка анимации, и вы возвращаетесь в цикл выполнения, где пользовательский интерфейс затем обновляется с остановкой.

Swift 3, 4 и 5

Запуск кода в основном потоке

DispatchQueue.main.async {
    // Your code here
}

Асинхронный означает асинхронный, и вы должны использовать его большую часть времени. Вы никогда не должны вызывать синхронизацию в основном потоке, потому что это заблокирует ваш пользовательский интерфейс до тех пор, пока задача не будет завершена. Вот лучший способ сделать это в Swift:

runThisInMainThread { () -> Void in
    // Run your code like this:
    self.doStuff()
}

func runThisInMainThread(block: dispatch_block_t) {
    dispatch_async(dispatch_get_main_queue(), block)
}

Он включен в качестве стандартной функции в мое репо, проверьте это: https://github.com/goktugyil/EZSwiftExtensions