У меня есть вопрос вокруг этого кода

dispatch_async(dispatch_get_global_queue( DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    NSData* data = [NSData dataWithContentsOfURL: 
      kLatestKivaLoansURL];
    [self performSelectorOnMainThread:@selector(fetchedData:) 
      withObject:data waitUntilDone:YES];
});

Первый параметр этого кода

dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0) 

Мы просим этот код выполнить последовательные задачи в глобальной очереди, само определение которой состоит в том, что он возвращает глобальную параллельную очередь с заданным уровнем приоритета?

В чем преимущество использования dispatch_get_global_queueнад основной очередью?

Я смущен. Не могли бы вы помочь мне понять это лучше.

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

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

dispatch_async(dispatch_get_global_queue( DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^(void){
    //Background Thread
    dispatch_async(dispatch_get_main_queue(), ^(void){
        //Run UI Updates
    });
});

Все очереди DISPATCH_QUEUE_PRIORITY_X являются параллельными очередями (то есть они могут выполнять несколько задач одновременно) и являются FIFO в том смысле, что задачи в данной очереди начнут выполняться в порядке «первым пришел, первым вышел». Это по сравнению с основной очередью (из dispatch_get_main_queue ()), которая является последовательной очередью (задачи начнут выполняться и завершатся в порядке их поступления).

Итак, если вы отправите 1000 блоков dispatch_async () в DISPATCH_QUEUE_PRIORITY_DEFAULT, эти задачи начнут выполняться в том порядке, в котором вы отправили их в очередь. Аналогично для очередей HIGH, LOW и BACKGROUND. Все, что вы отправляете в любую из этих очередей, выполняется в фоновом режиме в альтернативных потоках, вне основного потока приложения. Поэтому эти очереди подходят для выполнения таких задач, как фоновая загрузка, сжатие, вычисления и т. Д.

Обратите внимание, что порядок выполнения FIFO для каждой очереди. Поэтому, если вы отправляете 1000 задач dispatch_async () в четыре разные параллельные очереди, равномерно разделяя их и отправляя их по порядку BACKGROUND, LOW, DEFAULT и HIGH (т.е. вы планируете последние 250 задач в очереди HIGH), очень вероятно, что первые задачи, которые вы запускаете, будут в этой ВЫСОКОЙ очереди, поскольку система поняла, что эти задачи должны как можно быстрее попасть в ЦП.

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

Согласно Apple:

https://developer.apple.com/library/content/documentation/General/Conceptual/ConcurrencyProgrammingGuide/OperationQueues/OperationQueues.html

Параллельная очередь отправки полезна, когда у вас есть несколько задач, которые могут выполняться параллельно. Параллельная очередь по-прежнему является очередью в том смысле, что она распределяет задачи по очереди в порядке поступления; однако параллельная очередь может заблокировать дополнительные задачи до того, как завершатся все предыдущие задачи. Фактическое число задач, выполняемых параллельной очередью в любой момент времени, является переменным и может динамически изменяться при изменении условий в вашем приложении. Многие факторы влияют на количество задач, выполняемых параллельными очередями, включая количество доступных ядер, объем работы, выполняемой другими процессами, а также количество и приоритет задач в других последовательных очередях отправки.

По сути, если вы отправите эти 1000 блоков dispatch_async () в очередь DEFAULT, HIGH, LOW или BACKGROUND, все они начнут выполняться в порядке их отправки. Однако более короткие задачи могут закончиться раньше, чем более длинные. Причины этого заключаются в том, есть ли доступные ядра ЦП или если текущие задачи очереди выполняют вычислительно не интенсивную работу (таким образом, заставляя систему думать, что она может отправлять дополнительные задачи параллельно, независимо от количества ядер).

Уровень параллелизма полностью обрабатывается системой и основан на загрузке системы и других внутренних факторах. В этом прелесть Grand Central Dispatch (система dispatch_async ()) - вы просто делаете свои рабочие блоки кодовыми блоками, устанавливаете для них приоритет (в зависимости от выбранной вами очереди) и позволяете системе обрабатывать все остальное.

Итак, чтобы ответить на ваш вопрос выше: вы частично правы. Вы «просите этот код» выполнить параллельные задачи в глобальной параллельной очереди с указанным уровнем приоритета. Код в блоке будет выполняться в фоновом режиме, и любой дополнительный (аналогичный) код будет выполняться потенциально параллельно в зависимости от оценки доступных ресурсов системой.

«Основная» очередь с другой стороны (из dispatch_get_main_queue ()) является последовательной очередью (не одновременной). Задачи, отправленные в главную очередь, всегда будут выполняться по порядку и всегда будут заканчиваться по порядку. Эти задачи также будут выполняться в потоке пользовательского интерфейса, поэтому он подходит для обновления пользовательского интерфейса сообщениями о ходе выполнения, уведомлениями о завершении и т. Д.

Swift версия

Это Swift-версия ответа Дэвида Objective-C. Вы используете глобальную очередь для запуска объектов в фоновом режиме и основную очередь для обновления пользовательского интерфейса.

DispatchQueue.global(qos: .background).async {
    
    // Background Thread
    
    DispatchQueue.main.async {
        // Run UI Updates
    }
}