Постановка задачи
Необходимо выполнять синхронные задачи, в которых не участвует код, связанный с пользовательским интерфейсом.
Решение
Воспользуйтесь функцией dispatch_sync.
Обсуждение
Иногда необходимо решать задачи, никак не связанные с пользовательским интерфейсом, либо осуществлять процессы, которые взаимодействуют и с пользовательским интерфейсом, но в то же время заняты решением долговременных задач. Например, вам может понадобиться загрузить изображение, а после загрузки отобразить его для пользователя. Процесс загрузки совершенно не связан с пользовательским интерфейсом.
Любая задача, не связанная с пользовательским интерфейсом, позволяет применять глобальные параллельные очереди, которые предоставляет GCD. Они могут выполняться как синхронно, так и асинхронно. Но синхронное выполнение не означает, что программа дожидается, пока выполнится определенный фрагмент кода, а потом продолжает работу. Это лишь означает, что параллельная очередь дождется выполнения вашей задачи и только потом перейдет к выполнению следующего блока кода, стоящего в очереди. Когда вы ставите в параллельную очередь блоковый объект, ваша собственная программа всегда продолжает работу, не дожидаясь, пока выполнится код, стоящий в очереди. Дело в том, что параллельные очереди (как понятно из их названия) выполняют свой код в неглавных потоках. (Из этого правила есть исключение: когда задача передается в параллельную или последовательную очередь посредством функции dispatch_sync, система iOS при наличии такой возможности запускает задачу в текущем потоке. А это может быть и главный поток в зависимости от актуальной ветви кода. Это специальная оптимизация, запрограммированная в GCD, и вскоре мы обсудим ее подробнее.)
Если вы отправляете синхронную задачу в параллельную очередь и в то же время отправляете синхронную задачу в другую параллельную очередь, то две эти синхронные задачи будут выполняться асинхронно друг относительно друга, так как относятся к двум разным параллельным очередям. Этот нюанс важно понимать, поскольку иногда необходимо гарантировать, что задача B начнет выполняться только после того, как завершится задача А. Чтобы обеспечить такую последовательность, эти две задачи нужно синхронно отправлять в одну и ту же очередь.
Синхронные задачи в диспетчерской очереди можно выполнять с помощью функции dispatch_sync. Все, что от вас требуется, — снабдить эту функцию описателем той очереди, в которой должна выполняться задача, а также блоком кода, который должен выполниться в данной очереди.
Рассмотрим пример. Данная функция выводит на консоль числа от 1 до 1000, всю последовательность подряд, и при этом не блокирует основной поток. Мы можем создать блоковый объект, выполняющий подсчет за нас, и синхронно (дважды) вызвать этот же блоковый объект:
void (^printFrom1To1000)(void) = ^{
NSUInteger counter = 0;
for (counter = 1;
counter <= 1000;
counter++){
NSLog(@"Counter = %lu — Thread = %@",
(unsigned long)counter,
[NSThread currentThread]);
}
};
Итак, попробуем активизировать этот блоковый объект с помощью GCD:
— (BOOL) application:(UIApplication *)application
didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{
dispatch_queue_t concurrentQueue =
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_sync(concurrentQueue, printFrom1To1000);
dispatch_sync(concurrentQueue, printFrom1To1000);
// Точка переопределения для дополнительной настройки
// после запуска приложения
[self.window makeKeyAndVisible];
return YES;
}
Запустив этот код, вы заметите, что счетчик работает в главном потоке даже при том, что вы поставили эту задачу на выполнение в параллельную очередь. Оказывается, что это явление — специальная оптимизация GCD. Функция dispatch_sync будет использовать актуальный поток, то есть поток, который вы задействуете при направлении задачи в очередь, всякий раз, когда это возможно. В этом и заключается упомянутая оптимизация. Вот что об этом пишет Apple в справке по GCD: «В целях оптимизации работы данная функция активизирует блок кода в актуальном потоке всякий раз, когда это возможно».
Чтобы выполнить вместо блокового объекта функцию на языке C и сделать это синхронно, в диспетчерской очереди, используйте функцию dispatch_sync_f. Давайте просто преобразуем код, написанный для блокового объекта printFrom1To1000, в эквивалентную ему функцию на языке C:
void printFrom1To1000(void *paramContext){
NSUInteger counter = 0;
for (counter = 1;
counter <= 1000;
counter++){
NSLog(@"Counter = %lu — Thread = %@",
(unsigned long)counter,
[NSThread currentThread]);
}
}
А теперь можно воспользоваться функцией dispatch_sync_f для выполнения функции printFrom1To1000 в параллельной очереди:
— (BOOL) application:(UIApplication *)application
didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{
dispatch_queue_t concurrentQueue =
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_sync_f(concurrentQueue,
NULL,
printFrom1To1000);
dispatch_sync_f(concurrentQueue,
NULL,
printFrom1To1000);
self.window = [[UIWindow alloc]
initWithFrame: [[UIScreen mainScreen] bounds]];
self.window.backgroundColor = [UIColor whiteColor];
[self.window makeKeyAndVisible];
return YES;
}
Первый параметр функции dispatch_get_global_queue указывает приоритет параллельной очереди. Этот показатель GCD должен получить и предоставить программисту. Чем выше приоритет, тем больше квантов процессорного времени будет уделяться коду, выполняемому в этой очереди. В качестве первого параметра функции dispatch_get_global_queue можно использовать любое из следующих значений:
• DISPATCH_QUEUE_PRIORITY_LOW — ваша задача будет получать меньше процессорного времени, чем выделяется на задачу в среднем;
• DISPATCH_QUEUE_PRIORITY_DEFAULT — ваша задача получит стандартный системный приоритет;
• DISPATCH_QUEUE_PRIORITY_HIGH — ваша задача будет получать больше процессорного времени, чем выделяется на задачу в среднем.
Второй параметр функции dispatch_get_global_queue зарезервирован, ему всегда следует передавать значение 0.
В данном разделе было рассмотрено, как передавать задачи в параллельные очереди для синхронного исполнения. В следующем разделе обсудим асинхронное исполнение в параллельных очередях, а в разделе 7.10 будет показано, как исполнять задачи синхронно и асинхронно в последовательных очередях, создаваемых вами для приложений.
См. также
Разделы 7.6 и 7.10.
7.6. Асинхронное решение с помощью GCD задач, не связанных с пользовательским интерфейсом
Постановка задачи
Необходимо иметь возможность решать задачи, не связанные с пользовательским интерфейсом, с помощью GCD.
Решение
Вот здесь GCD и проявляется во всей красе: при асинхронном выполнении блоков кода в главной очереди, последовательных и параллельных очередях. Не сомневаюсь, что, дочитав этот раздел, вы будете совершенно убеждены в том, что будущее многопоточных приложений неразрывно связано с GCD, который в перспективе заменит потоки, применяемые в современных программах.
Чтобы выполнять в диспетчерской очереди асинхронные задачи, следует пользоваться одной из следующих функций:
• dispatch_async — отправляет блоковый объект в диспетчерскую очередь (и объект и очередь указываются в соответствующих параметрах) для асинхронного выполнения;
• dispatch_async_f — отправляет в диспетчерскую очередь функцию языка C вместе со ссылкой на контекст (все три элемента указываются в соответствующих параметрах) для асинхронного выполнения.
Обсуждение
Рассмотрим реальный пример. Напишем приложение для iOS, которое позволит нам скачивать изображение из Интернета по имеющейся гиперссылке (URL). После завершения загрузки наша программа должна отобразить изображение для пользователя. Далее приведен план работы и описано, как будут применены те или иные концепции, связанные с GCD, которые мы уже успели изучить.
1. Мы собираемся асинхронно запускать блоковый объект в параллельной очереди.
2. В ходе выполнения этого блока будем однократно (синхронно) запускать другой блоковый объект. Его мы будем использовать для скачивания изображения по URL, при этом будет применяться функция dispatch_sync. Мы поступаем именно так, поскольку хотим, чтобы обработка остального кода, стоящего в данной параллельной очереди, не начиналась, пока не загрузится изображение. В результате мы заставляем подождать только одну параллельную очередь, а не все остальные очереди. Если синхронно скачивать файл по URL из асинхронного блока кода, мы заблокируем лишь очередь, обрабатывающую синхронную функцию, но не главный поток. Вся операция так и остается асинхронной с точки зрения главного потока. Мы решаем основную задачу: при загрузке изображения главный поток не блокируется.
3. Сразу после того, как загрузка изображения завершится, мы синхронно выполним блоковый объект в главной очереди (см. раздел 7.4), чтобы отобразить картинку в пользовательском интерфейсе.
Каркас для планируемой программы совершенно прост:
— (void) viewDidAppear:(BOOL)animated{
[super viewDidAppear: animated];
dispatch_queue_t concurrentQueue =
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_async(concurrentQueue, ^{
__block UIImage *image = nil;
dispatch_sync(concurrentQueue, ^{
/* Здесь скачивается изображение. */
});
dispatch_sync(dispatch_get_main_queue(), ^{
/* Здесь мы демонстрируем изображение пользователю и делаем это
в главной очереди. */
});
});
}
Второй вызов к dispatch_sync, после которого отобразится картинка, будет выполняться в очереди после первого синхронного вызова, который обеспечивает загрузку изображения. Именно этого мы и добивались, поскольку нам необходимо дождаться, пока изображение загрузится полностью, и только после этого мы сможем отобразить его для пользователя. Итак, после завершения скачивания изображения мы выполняем второй блоковый объект, но на этот раз — в главной очереди.
Скачаем изображение и отобразим его для пользователя. Это мы сделаем в методе экземпляра viewDidAppear:, относящемся к контроллеру вида, который в данный момент отображается в приложении для iPhone:
— (void) viewDidAppear:(BOOL)paramAnimated{
[super viewDidAppear: paramAnimated];
dispatch_queue_t concurrentQueue =
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_async(concurrentQueue, ^{
__block UIImage *image = nil;
dispatch_sync(concurrentQueue, ^{
/* Здесь скачивается изображение. */
/* Изображение iPad с сайта Apple. Гиперссылка слишком длинная,
поэтому ее нужно правильно разбить на две строки. */
NSString *urlAsString = @"http://images.apple.com/mobileme/features"\
«/images/ipad_findyouripad_201 00518.jpg»;
NSURL *url = [NSURL URLWithString: urlAsString];
NSURLRequest *urlRequest = [NSURLRequest requestWithURL: url];
NSError *downloadError = nil;
NSData *imageData = [NSURLConnection
sendSynchronousRequest: urlRequest
returningResponse: nil
error:&downloadError];
if (downloadError == nil &&
imageData!= nil){
image = [UIImage imageWithData: imageData];
/* Изображение у нас есть. Теперь можно его использовать. */
}
else if (downloadError!= nil){
NSLog(@"Error happened = %@", downloadError);
} else {
NSLog(@"No data could get downloaded from the URL.");
}
});
dispatch_sync(dispatch_get_main_queue(), ^{
/* Здесь картинка отображается, и это происходит в главной очереди. */
if (image!= nil){
/* Здесь создается вид с изображением. */
UIImageView *imageView = [[UIImageView alloc]
initWithFrame: self.view.bounds];
/* Задаем характеристики изображения. */
[imageView setImage: image];
/* Убеждаемся, что изображение масштабировано правильно. */
[imageView setContentMode: UIViewContentModeScaleAspectFit];
/* Добавляем изображение к виду данного контроллера вида. */
[self.view addSubview: imageView];
} else {
NSLog(@"Image isn't downloaded. Nothing to display.");
}
});
});
}
Как показано на рис. 7.2, мы успешно загрузили изображение, а также создали вид изображения, в котором картинка будет представлена пользователю в графическом интерфейсе.
Рис. 7.2. Загрузка изображения и демонстрация его пользователю, применяется GCD
Приведем другой пример. Допустим, у нас есть массив из 10 000 случайных чисел, которые сохранены в файле на диске. Мы хотим загрузить этот файл в память и отсортировать числа в порядке возрастания (то есть сделать так, чтобы список начинался с наименьшего числа). Потом мы хотим отобразить полученный список для пользователя. Инструмент управления, который будет применяться при этой операции, определяется тем, для какой системы вы пишете программу. В случае с iOS идеальным выходом было бы использовать экземпляр UITableView, а при работе с Mac OS X — экземпляр NSTableView. Поскольку массива у нас еще нет, начнем с его создания, потом загрузим этот массив, а потом отобразим.
Вот два метода, которые помогут нам найти место на диске устройства, где мы собираемся сохранить массив из 10 000 случайных чисел:
— (NSString *) fileLocation{
/* Получаем каталог (-и) документа. */
NSArray *folders =
NSSearchPathForDirectoriesInDomains(NSDocumentDirectory,
NSUserDomainMask,
YES);
/* Мы что-нибудь нашли? */
if ([folders count] == 0){
return nil;
}
/* Получаем первый каталог. */
NSString *documentsFolder = [folders objectAtIndex:0];
/* Прикрепляем имя файла к концу пути документа. */
return [documentsFolder
stringByAppendingPathComponent:@"list.txt"];
}
— (BOOL) hasFileAlreadyBeenCreated{
BOOL result = NO;
NSFileManager *fileManager = [[NSFileManager alloc] init];
if ([fileManager fileExistsAtPath: [self fileLocation]]){
result = YES;
}
return result;
}
А вот теперь очень важный нюанс. Мы хотим сохранить на диске массив из 10 000 случайных чисел, если, и только если мы не создавали такой массив на диске раньше. В противном случае мы сразу загрузим массив с диска. Если же прежде мы не создавали этот массив на диске, то сначала создадим его, а потом перейдем к загрузке массива с диска. В итоге, если считывание массива с диска пройдет успешно, мы отсортируем этот массив в порядке возрастания и, наконец, отобразим результаты для пользователя в графическом интерфейсе. Реализацию отображения результатов пользователю оставляю вам для самостоятельной работы.
— (void) viewDidAppear:(BOOL)paramAnimated{
[super viewDidAppear: paramAnimated];
dispatch_queue_t concurrentQueue =
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
/* Если мы еще не отсортировали массив из 10 000 случайных чисел
на диске ранее, сгенерируем эти числа сейчас, а потом сохраним
их на диск в массиве. */
dispatch_async(concurrentQueue, ^{
NSUInteger numberOfValuesRequired = 10000;
if ([self hasFileAlreadyBeenCreated] == NO){
dispatch_sync(concurrentQueue, ^{
NSMutableArray *arrayOfRandomNumbers =
[[NSMutableArray alloc] initWithCapacity: numberOfValuesRequired];
NSUInteger counter = 0;
for (counter = 0;
counter < numberOfValuesRequired;
counter++){
unsigned int randomNumber =
arc4random() % ((unsigned int)RAND_MAX + 1);
[arrayOfRandomNumbers addObject:
[NSNumber numberWithUnsignedInt: randomNumber]];
}
/* Теперь записываем массив на диск. */
[arrayOfRandomNumbers writeToFile: [self fileLocation]
atomically: YES];
});
}
__block NSMutableArray *randomNumbers = nil;
/* Считываем числа с диска и сортируем их в порядке возрастания. */
dispatch_sync(concurrentQueue, ^{
/* Если файл на данный момент уже создан, занимаемся его считыванием. */
if ([self hasFileAlreadyBeenCreated]){
randomNumbers = [[NSMutableArray alloc]
initWithContentsOfFile: [self fileLocation]];
/* Теперь сортируем числа. */
[randomNumbers sortUsingComparator:
^NSComparisonResult(id obj1, id obj2) {
NSNumber *number1 = (NSNumber *)obj1;
NSNumber *number2 = (NSNumber *)obj2;
return [number1 compare: number2];
}];
}
});
dispatch_async(dispatch_get_main_queue(), ^{
if ([randomNumbers count] > 0){
/* Обновляем пользовательский интерфейс, задействуя числа
из массива randomNumbers. */
}
});
});
}
Функционал GCD далеко не ограничивается синхронным или асинхронным выполнением блоков кода или функций. В разделе 7.9 вы научитесь группировать блоковые объекты и готовить их к выполнению в диспетчерской очереди. Кроме того, рекомендую вам изучить разделы 7.7. и 7.8, где говорится о прочих функциях, которые предоставляются программисту в GCD.
См. также
Разделы 7.4, 7.7 и 7.8.
7.7. Выполнение задач после задержки с помощью GCD