Об очередях отгрузки

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

Очередь отгрузки является подобной объекту структурой, управляющей задачами, которые Вы представляете ей. Все очереди отгрузки являются структурами данных метода «первым пришел - первым вышел». Таким образом задачи, которые Вы добавляете к очереди, всегда запускаются в том же порядке, что они были добавлены. GCD предоставляет некоторые очереди отгрузки Вам автоматически, но другие можно создать в определенных целях. Таблица 3-1 перечисляет типы очередей отгрузки, доступных Вашему приложению и как Вы используете их.

Когда дело доходит до добавляющего параллелизма к приложению очереди отгрузки обеспечивают несколько преимуществ перед потоками. Самое прямое преимущество является простотой модели программирования рабочего списка. С потоками необходимо записать код и для работы, которую Вы хотите выполнить и для создания и управления самими потоками. Очереди отгрузки позволяют Вам фокусироваться на работе, которую Вы фактически хотите выполнить, не имея необходимость волноваться о создании потока и управлении. Вместо этого система обрабатывает все создание потока и управление для Вас. Преимущество состоит в том, что система в состоянии управлять потоками намного более эффективно, чем какое-либо отдельное приложение когда-нибудь могло. Система может масштабировать число потоков динамично на основе условий существующей системы и доступных ресурсов. Кроме того, система обычно в состоянии начать выполнять Вашу задачу более быстро, чем Вы могли при создании потока сами.

Несмотря на то, что Вы могли бы думать, переписывая Ваш код для очередей отгрузки, будет трудным, часто проще записать код для очередей отгрузки, чем это должно записать код для потоков. Ключ к записи Вашего кода должен разработать задачи, которые являются автономными и в состоянии работать асинхронно. (Это - фактически истина для обоих потоков и очередей отгрузки.) Однако то, где очереди отгрузки имеют преимущество, находится в предсказуемости. Если у Вас есть две задачи, получающие доступ к тому же совместно используемому ресурсу, но работающие на различных потоках, любой поток мог изменить ресурс сначала, и необходимо будет использовать блокировку, чтобы гарантировать, что обе задачи не изменяли тот ресурс одновременно. С очередями отгрузки Вы могли добавить обе задачи к последовательной очереди отгрузки гарантировать, что только одна задача изменила ресурс в любой момент времени. Этот тип основанной на очереди синхронизации более эффективен, чем блокировки, потому что блокировки всегда требуют дорогого прерывания ядра и в оспариваемых и в неоспоримых случаях, тогда как очередь отгрузки работает прежде всего в пространстве процесса Вашего приложения и только раскритиковывает к ядру при необходимости.

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

Некоторые другие ключевые пункты для запоминания об очередях отгрузки включают следующее:

• Очереди отгрузки выполняют свои задачи одновременно с уважением к другим очередям отгрузки. Сериализация задач ограничивается задачами в единственной очереди отгрузки.

• Система определяет общее количество задач, выполняющихся в любой момент. Таким образом приложение с 100 задачами в 100 различных очередях может не выполнить все те задачи одновременно (если оно не имеет 100 или больше эффективных ядер).

• Система принимает приоритетные уровни очереди во внимание при выборе который новые задачи запуститься. Для получения информации о том, как установить приоритет последовательной очереди, посмотрите Обеспечение Очистить Функции Для Очереди.

• Задачи в очереди должны быть готовы выполниться в то время, когда они добавляются к очереди. (При использовании объектов операции Какао прежде заметьте, что это поведение отличается от использования операций модели.)

• Частные очереди отгрузки считаются на ссылку объекты. В дополнение к сохранению очереди в Вашем собственном коде, знать, что источники отгрузки могут также быть присоединены к очереди и также постепенно увеличить сохранять количество. Таким образом необходимо удостовериться, что все источники отгрузки отменяются, и все сохраняют вызовы, сбалансированы с надлежащего вызова выпуска. Для получения дополнительной информации о сохранении и выпуске очередей, посмотрите управление памятью для Очередей Отгрузки. Для получения дополнительной информации об источниках отгрузки, займитесь Источниками Отгрузки.

Для получения дополнительной информации об интерфейсах Вы используете, чтобы управлять очередями отгрузки, видеть Ссылку Grand Central Dispatch (GCD).

Queue-Related Technologies

Кроме того, для диспетчеризации очередей Центральная Отгрузка обеспечивает несколько технологий, использующих очереди, чтобы помочь управлять кодом. Таблица 3-2 перечисляет эти технологии и обеспечивает ссылки туда, где можно узнать больше информации о них.

Реализация задач Используя блоки

Блочные объекты являются функцией языка на базе С, которую можно использовать в C, Objective C и коде C++. Блоки упрощают определять автономное устройство работы. Несмотря на то, что они могли бы казаться сродни указателям функции, блок фактически представлен базовой структурой данных, напоминающей объект и создающейся и управляющейся для Вас компилятором. Пакеты компилятора код Вы обеспечиваете (вместе с любыми связанными данными), и инкапсулирует его в форме, которая может жить в «куче» и быть роздана Ваше приложение.

Одно из главных преимуществ блоков является их возможностью использовать переменные извне их собственного лексического контекста. При определении блока в функции или методе, блочные действия как традиционный блок кода был бы до некоторой степени. Например, блок может считать значения переменных, определенных в родительском объеме. Переменные, к которым получает доступ блок, копируются в блочную структуру данных на «куче» так, чтобы блок мог получить доступ к ним позже. Когда блоки добавляются к очереди отгрузки, эти значения нужно обычно оставлять в формате только для чтения. Однако блоки, выполняющиеся синхронно, могут также использовать переменные, имеющие __block ключевое слово, предварительно ожидаемое для возврата данных назад объему вызова родителя.

Вы объявляете блоки, встроенные с Вашим кодом с помощью синтаксиса, который подобен синтаксису, используемому для указателей функции. Основное различие между блоком и указателем функции - то, что имени блока предшествуют с каре (^) вместо звездочки (*). Как указатель функции, можно передать параметры блоку и получить возвращаемое значение от него. Перечисление 3-1 показывает Вам, как объявить и выполнить блоки синхронно в Вашем коде. Переменная aBlock как объявляют, блок, берущий единственный целочисленный параметр и не возвращающий значения. Фактический блок, соответствующий тот прототип, тогда присваивается aBlock и объявленный встроенным. Последняя строка сразу выполняет блок, распечатывая указанные целые числа к стандарту.

Перечисление 3-1  простой блочный пример

int x = 123;

int y = 456;

// Block declaration and assignment

void (^aBlock)(int) = ^(int z) {

    printf("%d %d %d\n", x, y, z);

};

// Execute the block

aBlock(789);   // prints: 123 456 789

Следующее является сводкой некоторых ключевых инструкций, которые необходимо рассмотреть при разработке блоков:

• Для блоков, что Вы планируете выполнить асинхронно использование очереди отгрузки, безопасно получить скалярные переменные от родительской функции или метода и использовать их в блоке. Однако Вы не должны пытаться получить большие структуры или другие базируемые переменные указателя, выделенные и удаленные контекстом вызова. К тому времени, когда Ваш блок выполняется, память, на которую ссылается тот указатель, может закончиться. Конечно, безопасно выделить память (или объект) самостоятельно и явно вручить от владения той памяти к блоку.

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

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

• Не делайте данных кэша относительно базового потока и ожидайте что данные быть доступными от различного блока. Если задачи в той же очереди должны совместно использовать данные, используйте указатель контекста очереди отгрузки, чтобы хранить данные вместо этого. Для получения дополнительной информации о том, как получить доступ к данным контекста очереди отгрузки, посмотрите Хранящую Пользовательскую Контекстную информацию с Очередью.

• Если Ваш блок создает больше, чем несколько объектов Objective C, Вы могли бы хотеть включить части кода своего блока в блоке @autorelease для обработки управления памятью для тех объектов. Несмотря на то, что у очередей отгрузки GCD есть свои собственные пулы автовыпуска, они не делают гарантий относительно того, когда истощены те пулы. Если Ваше приложение является ограниченной памятью, создавание Вашего собственного пула автовыпуска позволяет Вам высвобождать память для автовыпущенных объектов в более равных интервалах.

Для получения дополнительной информации о блоках, включая то, как объявить и использовать их, посмотрите, что Блоки Программируют Темы. Для получения информации о том, как Вы добавляете блоки к очереди отгрузки, видите Добавляющие Задачи Очереди.

Создание и управление очередями отгрузки

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

dispatch_queue_t aQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

dispatch_queue_t queue;

queue = dispatch_queue_create("com.example.MyQueue", NULL);

void myFinalizerFunction(void *context)

{

    MyDataContext* theData = (MyDataContext*)context;

    // Clean up the contents of the structure

    myCleanUpDataContextFunction(theData);

    // Now release the structure itself.

    free(theData);

}

dispatch_queue_t createMyQueue()

{

    MyDataContext*  data = (MyDataContext*) malloc(sizeof(MyDataContext));

    myInitializeDataContextFunction(data);

    // Create the queue and set the context data.

    dispatch_queue_t serialQueue = dispatch_queue_create("com.example.CriticalTaskQueue", NULL);

    if (serialQueue)

    {

        dispatch_set_context(serialQueue, data);

        dispatch_set_finalizer_f(serialQueue, &myFinalizerFunction);

    }

    return serialQueue;

}

Добавление задач очереди

Для выполнения задачи необходимо диспетчеризировать его соответствующей очереди отгрузки. Можно диспетчеризировать задачи синхронно или асинхронно, и можно диспетчеризировать их отдельно или в группах. Один раз в очереди, очередь становится ответственной за выполнение Ваших задач как можно скорее учитывая его ограничения и существующие задачи уже в очереди. Этот раздел показывает Вам некоторые методы для диспетчеризации задач очереди и описывает преимущества каждого.

dispatch_queue_t myCustomQueue;

myCustomQueue = dispatch_queue_create("com.example.MyCustomQueue", NULL);

dispatch_async(myCustomQueue, ^{

    printf("Do some work here.\n");

});

printf("The first block may or may not have run.\n");

dispatch_sync(myCustomQueue, ^{

    printf("Do some more work here.\n");

});

printf("Both blocks have completed.\n");

void average_async(int *data, size_t len,

   dispatch_queue_t queue, void (^block)(int))

{

   // Retain the queue provided by the user to make

   // sure it does not disappear before the completion

   // block can be called.

   dispatch_retain(queue);

   // Do the work on the default concurrent queue and then

   // call the user-provided block with the results.

   dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

      int avg = average(data, len);

      dispatch_async(queue, ^{ block(avg);});

      // Release the user-provided queue when done

      dispatch_release(queue);

   });

}

for (i = 0; i < count; i++) {

   printf("%u\n",i);

}

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

dispatch_apply(count, queue, ^(size_t i) {

   printf("%u\n",i);

});

Приостановка и возобновление очередей

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

Используя семафоры отгрузки для регулирования использования конечных ресурсов

Если задачи можно хотеть использовать семафор отгрузки для регулирования числа задач, одновременно получающих доступ к тому ресурсу, которые Вы представляете для диспетчеризации доступа очередей некоторый конечный ресурс. Семафор отгрузки работает как регулярный семафор за одним исключением. Когда ресурсы доступны, требуется меньше времени для получения семафора отгрузки, чем это делает для получения традиционного системного семафора. Это вызвано тем, что Центральная Отгрузка не раскритиковывает в ядро за этот особый случай. Единственное время, которое это раскритиковывает в ядро, - когда ресурс не доступен, и система должна парковать Ваш поток, пока не сообщен семафор.

Семантика для использования семафора отгрузки следующие:

1. Когда Вы создаете семафор (использование dispatch_semaphore_create функция), можно указать положительное целое число, указывающее число доступных ресурсов.

2. В каждой задаче вызвать dispatch_semaphore_wait ожидать на семафоре.

3. Когда вызов ожидания возвратится, получите ресурс и выполните свою работу.

4. Когда Вы сделаны с ресурсом, выпускаете его и сигнализируете семафор путем вызова dispatch_semaphore_signal функция.

Для примера того, как эти шаги работают, рассмотрите использование дескрипторов файлов в системе. Каждому приложению дают ограниченное количество дескрипторов файлов для использования. Если у Вас есть задача, обрабатывающая большие количества файлов, Вы не хотите открывать столько файлов когда-то, что Вы исчерпываете дескрипторы файлов. Вместо этого можно использовать семафор для ограничения числа дескрипторов файлов в использовании в любой момент кодом обработки файла. Основные части кода, который Вы включили бы в свои задачи, следующие:

// Create the semaphore, specifying the initial pool size

dispatch_semaphore_t fd_sema = dispatch_semaphore_create(getdtablesize() / 2);

// Wait for a free file descriptor

dispatch_semaphore_wait(fd_sema, DISPATCH_TIME_FOREVER);

fd = open("/etc/services", O_RDONLY);

// Release the file descriptor when done

close(fd);

dispatch_semaphore_signal(fd_sema);

При создании семафора Вы указываете число доступных ресурсов. Это значение становится начальной переменной количества для семафора. Каждый раз Вы ожидаете на семафоре, dispatch_semaphore_wait функционируйте декременты, считающие переменную 1. Если получающееся значение отрицательно, функция говорит ядру блокировать Ваш поток. На другом конце, dispatch_semaphore_signal функционируйте постепенно увеличивает переменную количества 1, чтобы указать, что был высвобожден ресурс. Если существуют блокированные задачи и ожидающий ресурса, один из них впоследствии разблокируется и позволяется выполнить свою работу.

Ожидание на группах задач с очередями

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

Перечисление 3-6 показывает базовый процесс для установки группы, диспетчеризации задач к нему и ожидания на результатах. Вместо того, чтобы диспетчеризировать задачи очереди, использующей dispatch_async функция, Вы используете dispatch_group_async функция вместо этого. Эта функция связывает задачу с группой и ставит его в очередь для выполнения. Для ожидания на группе задач закончиться Вы тогда используете dispatch_group_wait функция, передающая в соответствующей группе.

Перечисление 3-6  , Ожидающее на асинхронных задачах

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

dispatch_group_t group = dispatch_group_create();

// Add a task to the group

dispatch_group_async(group, queue, ^{

   // Some asynchronous work

});

// Do some other work while the tasks execute.

// When you cannot make any more forward progress,

// wait on the group to block the current thread.

dispatch_group_wait(group, DISPATCH_TIME_FOREVER);

// Release the group when it is no longer needed.

dispatch_release(group);

Очереди отгрузки и потокобезопасность

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

• Сами очереди отгрузки ориентированы на многопотоковое исполнение. Другими словами, можно представить задачи очереди отгрузки от любого потока в системе без первого взятия блокировки или синхронизации доступа к очереди.

• Не вызывайте dispatch_sync функция от задачи, выполняющейся на той же очереди, которую Вы передаете своему вызову функции. Выполнение так заведет в тупик очередь. Если необходимо диспетчеризировать текущей очереди, сделайте так асинхронно использование dispatch_async функция.

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

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

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