Разница между dispatch_async и dispatch_sync в последовательной очереди?

Я создал такую ​​последовательную очередь:

    dispatch_queue_t _serialQueue = dispatch_queue_create("com.example.name", DISPATCH_QUEUE_SERIAL);

В чем разница между так dispatch_asyncназываемым

 dispatch_async(_serialQueue, ^{ /* TASK 1 */ });
 dispatch_async(_serialQueue, ^{ /* TASK 2 */ });

И так dispatch_syncзвонили в эту последовательную очередь?

 dispatch_sync(_serialQueue, ^{ /* TASK 1 */ });
 dispatch_sync(_serialQueue, ^{ /* TASK 2 */ });

Насколько я понимаю, независимо от того, какой метод отправки используется, TASK 1он будет выполнен и завершен раньше TASK 2, правильно?

Да. Использование последовательной очереди обеспечивает последовательное выполнение задач. Единственное отличие состоит в том, что dispatch_syncвозврат только после завершения блока, тогда как dispatch_asyncвозврат после того, как он добавлен в очередь и может не завершиться.

для этого кода

dispatch_async(_serialQueue, ^{ printf("1"); });
printf("2");
dispatch_async(_serialQueue, ^{ printf("3"); });
printf("4");

Он может печатать 2413или 2143или , 1234но 1всегда перед3

для этого кода

dispatch_sync(_serialQueue, ^{ printf("1"); });
printf("2");
dispatch_sync(_serialQueue, ^{ printf("3"); });
printf("4");

он всегда печатает 1234

Примечание. Первый код не печатается 1324. Потому printf("3")что отправляется после printf("2") выполнения. И задача может быть выполнена только после отправки.

Время выполнения задач ничего не меняет. Этот код всегда печатается12

dispatch_async(_serialQueue, ^{ sleep(1000);printf("1"); });
dispatch_async(_serialQueue, ^{ printf("2"); });

Что может случиться

• Поток 1: dispatch_async трудоемкая задача (задача 1) в последовательную очередь
• Поток 2: начать выполнение задачи 1
• Поток 1: dispatch_async другая задача (задача 2) в последовательную очередь
• Тема 2: задача 1 завершена. начать выполнение задачи 2
• Тема 2: задача 2 завершена.

и ты всегда видишь 12

Разница между dispatch_syncи dispatch_asyncпроста.

В обоих ваших примерах TASK 1всегда будет выполняться раньше, TASK 2потому что он был отправлен до него.

В этом dispatch_syncпримере, однако, вы не будете отправлять сообщения TASK 2до TASK 1тех пор, пока они не будут отправлены и выполнены . Это называется «блокировкой» . Ваш код ждет (или «блокируется»), пока задача не будет выполнена.

В этом dispatch_asyncпримере ваш код не будет ждать завершения выполнения. Оба блока будут отправлены (и поставлены в очередь) в очередь, а остальная часть вашего кода продолжит выполнение в этом потоке. Затем в какой-то момент в будущем (в зависимости от того, что еще было отправлено в вашу очередь), Task 1будет выполнено, а затем Task 2будет выполнено.

Все это связано с основной очередью. Есть 4 перестановки.

i) Последовательная очередь, асинхронная отправка: здесь задачи будут выполняться одна за другой, но основной поток (влияние на пользовательский интерфейс) не будет ждать возврата

ii) Последовательная очередь, диспетчерская синхронизация: здесь задачи будут выполняться одна за другой, но основной поток (влияние на пользовательский интерфейс) будет показывать задержку

iii) Параллельная очередь, асинхронная отправка: здесь задачи будут выполняться параллельно, и основной поток (влияние на пользовательский интерфейс) не будет ждать возврата и будет плавным.

iv) Параллельная очередь, диспетчерская синхронизация: здесь задачи будут выполняться параллельно, но основной поток (влияние на пользовательский интерфейс) будет показывать задержку

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

И, наконец, это способ вернуться к основному потоку, когда мы закончим наши дела:

DispatchQueue.main.async {
     // Do something here
}