Параллельное и синхронное выполнение

Question

Я читал OReilly Программу программирования iOS6 и кое-что смущен. Цитата из стр. 378, глава 6 «Параллельность»:

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

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

Правильно это или как это работает?

Answer 1

Автор Vandad Nahavandipoor, я не хочу, чтобы повлиять на доход от продаж этого парня, но все его книги содержат одни и те же ошибки в главах параллелизма:

http://www.amazon.com/Vandad-Nahavandipoor/e/B004JNSV7I/ref=sr_tc_2_rm?qid=1381231858&sr=8-2-ent

Что иронично, так как у него есть 50-страничная книга именно на эту тему.

http://www.amazon.com/Concurrent-Programming-Mac-iOS-Performance/dp/1449305636/ref=la_B004JNSV7I_1_6?s=books&ie=UTF8&qid=1381232139&sr=1-6

Люди должны перестать читать книги этого парня.

Answer 2

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

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

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

Подробнее: https://developer.apple.com/library/ios/documentation/General/Conceptual/ConcurrencyProgrammingGuide/OperationQueues/OperationQueues.html

Answer 3

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

Мне кажется, что это сбивает с толку, и единственным объяснением, о котором я могу думать, является то, что она говорит о том, кто блокирует кого. От man dispatch_sync:

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

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

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

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

Answer 4

Как этот абзац неправильно? Подсчитаем пути:

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

Это слишком специфично и неточно. Определенные задачи пользовательского интерфейса, такие как загрузка изображений, могут выполняться с основного потока. Это было бы лучше сказать как «В большинстве случаев не взаимодействовать с классами UIKit, кроме основного потока», но есть исключения (например, рисование на UIGraphicsContext является потокобезопасным с iOS 4, IIRC и рисунком является отличным примером задачи с интенсивным процессором, которая может быть выгружена в фоновый поток.) ​​FWIW - любое рабочее устройство, которое вы можете отправить в глобальную параллельную очередь, вы также можете отправить в приватную параллельную очередь.

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

Как предполагают iWasRobbed, они, похоже, имеют объединенную синхронизацию/асинхронную работу с последовательными/параллельными очередями. Синхронное выполнение делает, по определению, означает, что ваша программа ждет возврата кода перед продолжением. Асинхронное выполнение, по определению, означает, что ваша программа не ждет. Аналогично, очереди серийно выполняют только один поданный рабочий блок за раз, выполняя каждый в порядке FIFO. Параллельные очереди, частные или глобальные, в общем случае (больше в секунду), расписали представленные блоки для выполнения в том порядке, в котором они были установлены в очередь, на один или несколько фоновых потоков. Количество используемых фоновых потоков - непрозрачная деталь реализации.

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

Nope. Не правда. Опять же, они смешивают синхронизацию/асинхронную и последовательную/параллельную. Я подозреваю, что они пытаются сказать: когда вы вставляете асинхронный блок, ваша собственная программа всегда остается незамеченной, не дожидаясь очереди для выполнения кода.

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

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

В целом, весь этот параграф действительно довольно ужасен и вводит в заблуждение.

EDIT: Я упомянул об этом в комментарии к другому ответу, но было бы полезно поместить его здесь для ясности. Понятие «синхронная и асинхронная диспетчеризация» и концепция «последовательных или параллельных очередей» в основном ортогональны. Вы можете отправлять работу в любую очередь (последовательную или параллельную) либо синхронно, либо асинхронно. Синхронная/асинхронная дихотомия в первую очередь относится к «отправке» er * »(при этом она определяет, заблокирован ли диспетчер до завершения блока или нет), тогда как параллельная/параллельная дихотомия в первую очередь относится к отправке * ee * блок (в котором он определяет, может ли диспетчер потенциально выполняться одновременно с другими блоками или нет).