Выполненные режимы цикла

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

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

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

Таблица 3-1 перечисляет стандартные режимы, определенные Какао и Базовой Основой вместе с описанием того, когда Вы используете тот режим. Списки столбцов имени фактические константы Вы используете для указания режима в коде.

Входные источники

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

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

Следующие разделы описывают некоторые входные источники.

Источники таймера

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

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

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

Для получения дополнительной информации о конфигурировании источников таймера посмотрите Источники Таймера Конфигурирования. Для справочной информации см. Ссылку Ссылки класса или CFRunLoopTimer NSTimer.

Выполненные наблюдатели цикла

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

• Вход к циклу выполнения.

• Когда цикл выполнения собирается обработать таймер.

• Когда цикл выполнения собирается обработать входной источник.

• Когда цикл выполнения собирается заснуть.

• Когда цикл выполнения проснулся, но прежде чем он обработал событие, разбудившее его.

• Выход от цикла выполнения.

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

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

Для примера того, как создать наблюдателя цикла выполнения, посмотрите Конфигурирование Цикла Выполнения. Для справочной информации посмотрите Ссылку CFRunLoopObserver.

Последовательность цикла выполнения событий

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

1. Уведомьте наблюдателей, что был введен цикл выполнения.

2. Уведомьте наблюдателей, что любые готовые таймеры собираются стрелять.

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

4. Увольте любого не, порт базировал входные источники, которые готовы стрелять.

5. Если основанный на порте входной источник готов и ожидает для увольнения, обработайте событие сразу. Перейдите к шагу 9.

6. Уведомьте наблюдателей, что поток собирается спать.

7. Поместите поток для сна, пока одно из следующих событий не будет иметь место:

   • Событие поступает для основанного на порте входного источника.

   • Таймер стреляет.

   • Набор значений тайм-аута для цикла выполнения истекает.

   • Цикл выполнения явно разбужен.

8. Уведомьте наблюдателей, что просто проснулся поток.

9. Обработайте незаконченное событие.

   • Если определяемый пользователем таймер стрелял, обработайте событие таймера и перезапустите цикл. Перейдите к шагу 2.

   • Если входной источник стрелял, поставьте событие.

   • Если цикл выполнения был явно разбужен, но еще не испытал таймаут, перезапустите цикл. Перейдите к шагу 2.

10. Уведомьте наблюдателей, что вышел цикл выполнения.

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

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

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

Получение объекта цикла выполнения

Для получения цикла выполнения для текущего потока Вы используете одно из следующего:

• В приложении Какао используйте currentRunLoop метод класса NSRunLoop получать NSRunLoop объект.

• Используйте CFRunLoopGetCurrent функция.

Несмотря на то, что они не бесплатные соединенные мостом типы, можно получить a CFRunLoopRef непрозрачный тип от NSRunLoop возразите при необходимости. NSRunLoop класс определяет a getCFRunLoop метод, возвращающий a CFRunLoopRef введите это, можно передать Базовым подпрограммам Основы. Поскольку оба объекта относятся к тому же циклу выполнения, можно смешать вызовы к NSRunLoop объект и CFRunLoopRef непрозрачный тип по мере необходимости.

Конфигурирование цикла выполнения

Перед выполнением цикла выполнения на вторичном потоке необходимо добавить по крайней мере один входной источник или таймер к нему. Если цикл выполнения не имеет никаких источников для контроля, он выходит сразу, когда Вы пытаетесь выполнить его. Для примеров того, как добавить источники к циклу выполнения, посмотрите Источники Цикла Выполнения Конфигурирования.

В дополнение к установке источников можно также установить выполненных наблюдателей цикла и использовать их для обнаружения различных этапов выполнения цикла выполнения. Для установки наблюдателя цикла выполнения Вы создаете a CFRunLoopObserverRef непрозрачный тип и использование CFRunLoopAddObserver функция для добавления его к циклу выполнения. Выполненные наблюдатели цикла должны быть созданы с помощью Базовой Основы, даже для приложений Какао.

Перечисление 3-1 показывает основную подпрограмму для потока, присоединяющего наблюдателя цикла выполнения к его циклу выполнения. Цель примера состоит в том, чтобы показать Вам, как создать наблюдателя цикла выполнения, таким образом, код просто устанавливает наблюдателя цикла выполнения для контроля всех действий цикла выполнения. Основная подпрограмма обработчика (не показанный) просто регистрирует действие цикла выполнения, поскольку это обрабатывает запросы таймера.

Перечисление 3-1  , Создающее наблюдателя цикла выполнения

- (void)threadMain

{

    // The application uses garbage collection, so no autorelease pool is needed.

    NSRunLoop* myRunLoop = [NSRunLoop currentRunLoop];

    // Create a run loop observer and attach it to the run loop.

    CFRunLoopObserverContext  context = {0, self, NULL, NULL, NULL};

    CFRunLoopObserverRef    observer = CFRunLoopObserverCreate(kCFAllocatorDefault,

            kCFRunLoopAllActivities, YES, 0, &myRunLoopObserver, &context);

    if (observer)

    {

        CFRunLoopRef    cfLoop = [myRunLoop getCFRunLoop];

        CFRunLoopAddObserver(cfLoop, observer, kCFRunLoopDefaultMode);

    }

    // Create and schedule the timer.

    [NSTimer scheduledTimerWithTimeInterval:0.1 target:self

                selector:@selector(doFireTimer:) userInfo:nil repeats:YES];

    NSInteger    loopCount = 10;

    do

    {

        // Run the run loop 10 times to let the timer fire.

        [myRunLoop runUntilDate:[NSDate dateWithTimeIntervalSinceNow:1]];

        loopCount--;

    }

    while (loopCount);

}

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

Запуск цикла выполнения

Запуск цикла выполнения необходим только для вторичных потоков в Вашем приложении. Цикл выполнения должен иметь по крайней мере один входной источник или таймер для контроля. Если Вы не присоединяетесь, цикл выполнения сразу выходит.

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

• Безусловно

• С ограничением по времени набора

• В определенном режиме

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

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

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

Перечисление 3-2 показывает скелетную версию основной подпрограммы записи потока. Ключевая часть этого примера показывает базовую структуру цикла выполнения. В сущности Вы добавляете свои входные источники и таймеры к циклу выполнения и затем неоднократно вызываете одну из подпрограмм для запуска цикла выполнения. Каждый раз возвраты подпрограммы цикла выполнения, Вы проверяете, чтобы видеть, возникли ли какие-либо условия, который мог бы гарантировать выход из потока. Пример использует Базовую Основу выполненные подпрограммы цикла так, чтобы это могло проверить, что возврат заканчивается и определяет, почему вышел цикл выполнения. Вы могли также использовать методы NSRunLoop класс для выполнения цикла выполнения подобным образом, если Вы используете Какао и не должны проверять возвращаемое значение. (Для примера цикла выполнения, вызывающего методы NSRunLoop класс, см. Перечисление 3-14.)

Перечисление 3-2  , Выполняющее цикл выполнения

- (void)skeletonThreadMain

{

    // Set up an autorelease pool here if not using garbage collection.

    BOOL done = NO;

    // Add your sources or timers to the run loop and do any other setup.

    do

    {

        // Start the run loop but return after each source is handled.

        SInt32    result = CFRunLoopRunInMode(kCFRunLoopDefaultMode, 10, YES);

        // If a source explicitly stopped the run loop, or if there are no

        // sources or timers, go ahead and exit.

        if ((result == kCFRunLoopRunStopped) || (result == kCFRunLoopRunFinished))

            done = YES;

        // Check for any other exit conditions here and set the

        // done variable as needed.

    }

    while (!done);

    // Clean up code here. Be sure to release any allocated autorelease pools.

}

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

Выход из цикла выполнения

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

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

• Скажите циклу выполнения останавливаться.

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

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

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

Потокобезопасность и выполненные объекты цикла

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

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

Определение пользовательского входного источника

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

• Информация Вы хотите, чтобы Ваш входной источник обработал.

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

• Подпрограмма обработчика для выполнения запросов, отправленных любыми клиентами.

• Подпрограмма отмены для лишения законной силы входного источника.

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

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

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

@interface RunLoopSource : NSObject

{

    CFRunLoopSourceRef runLoopSource;

    NSMutableArray* commands;

}

- (id)init;

- (void)addToCurrentRunLoop;

- (void)invalidate;

// Handler method

- (void)sourceFired;

// Client interface for registering commands to process

- (void)addCommand:(NSInteger)command withData:(id)data;

- (void)fireAllCommandsOnRunLoop:(CFRunLoopRef)runloop;

@end

// These are the CFRunLoopSourceRef callback functions.

void RunLoopSourceScheduleRoutine (void *info, CFRunLoopRef rl, CFStringRef mode);

void RunLoopSourcePerformRoutine (void *info);

void RunLoopSourceCancelRoutine (void *info, CFRunLoopRef rl, CFStringRef mode);

// RunLoopContext is a container object used during registration of the input source.

@interface RunLoopContext : NSObject

{

    CFRunLoopRef        runLoop;

    RunLoopSource*        source;

}

@property (readonly) CFRunLoopRef runLoop;

@property (readonly) RunLoopSource* source;

- (id)initWithSource:(RunLoopSource*)src andLoop:(CFRunLoopRef)loop;

@end

void RunLoopSourceScheduleRoutine (void *info, CFRunLoopRef rl, CFStringRef mode)

{

    RunLoopSource* obj = (RunLoopSource*)info;

    AppDelegate*   del = [AppDelegate sharedAppDelegate];

    RunLoopContext* theContext = [[RunLoopContext alloc] initWithSource:obj andLoop:rl];

    [del performSelectorOnMainThread:@selector(registerSource:)

                                withObject:theContext waitUntilDone:NO];

}

void RunLoopSourcePerformRoutine (void *info)

{

    RunLoopSource*  obj = (RunLoopSource*)info;

    [obj sourceFired];

}

void RunLoopSourceCancelRoutine (void *info, CFRunLoopRef rl, CFStringRef mode)

{

    RunLoopSource* obj = (RunLoopSource*)info;

    AppDelegate* del = [AppDelegate sharedAppDelegate];

    RunLoopContext* theContext = [[RunLoopContext alloc] initWithSource:obj andLoop:rl];

    [del performSelectorOnMainThread:@selector(removeSource:)

                                withObject:theContext waitUntilDone:YES];

}

- (id)init

{

    CFRunLoopSourceContext    context = {0, self, NULL, NULL, NULL, NULL, NULL,

                                        &RunLoopSourceScheduleRoutine,

                                        RunLoopSourceCancelRoutine,

                                        RunLoopSourcePerformRoutine};

    runLoopSource = CFRunLoopSourceCreate(NULL, 0, &context);

    commands = [[NSMutableArray alloc] init];

    return self;

}

- (void)addToCurrentRunLoop

{

    CFRunLoopRef runLoop = CFRunLoopGetCurrent();

    CFRunLoopAddSource(runLoop, runLoopSource, kCFRunLoopDefaultMode);

}

- (void)registerSource:(RunLoopContext*)sourceInfo;

{

    [sourcesToPing addObject:sourceInfo];

}

- (void)removeSource:(RunLoopContext*)sourceInfo

{

    id    objToRemove = nil;

    for (RunLoopContext* context in sourcesToPing)

    {

        if ([context isEqual:sourceInfo])

        {

            objToRemove = context;

            break;

        }

    }

    if (objToRemove)

        [sourcesToPing removeObject:objToRemove];

}

- (void)fireCommandsOnRunLoop:(CFRunLoopRef)runloop

{

    CFRunLoopSourceSignal(runLoopSource);

    CFRunLoopWakeUp(runloop);

}

Конфигурирование источников таймера

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

В Какао можно создать и запланировать таймер одновременно с помощью любого из этих методов класса:

• scheduledTimerWithTimeInterval:target:selector:userInfo:repeats:

• scheduledTimerWithTimeInterval:invocation:repeats:

Эти методы создают таймер и добавляют его к циклу выполнения текущего потока в режиме по умолчанию (NSDefaultRunLoopMode). Если Вы захотите путем создания Вашего, можно также запланировать таймер вручную NSTimer возразите и затем добавление его к циклу выполнения с помощью addTimer:forMode: метод NSRunLoop. Оба метода делают в основном ту же вещь, но дают Вам разные уровни управления конфигурацией таймера. Например, если Вы создаете таймер и добавляете его к циклу выполнения вручную, можно сделать настолько использующий режим кроме режима по умолчанию. Перечисление 3-10 показывает, как создать таймеры с помощью обоих методов. Новичок имеет начальную задержку 1 секунды, но тогда стреляет регулярно каждую 0.1 секунды после этого. Второй таймер начинает стрелять после начальных 0,2 вторых задержек и затем стреляет каждые 0.2 секунды после этого.

Перечисление 3-10  Создающие и планирующие таймеры с помощью NSTimer

NSRunLoop* myRunLoop = [NSRunLoop currentRunLoop];

// Create and schedule the first timer.

NSDate* futureDate = [NSDate dateWithTimeIntervalSinceNow:1.0];

NSTimer* myTimer = [[NSTimer alloc] initWithFireDate:futureDate

                        interval:0.1

                        target:self

                        selector:@selector(myDoFireTimer1:)

                        userInfo:nil

                        repeats:YES];

[myRunLoop addTimer:myTimer forMode:NSDefaultRunLoopMode];

// Create and schedule the second timer.

[NSTimer scheduledTimerWithTimeInterval:0.2

                        target:self

                        selector:@selector(myDoFireTimer2:)

                        userInfo:nil

                        repeats:YES];

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

  Создание перечисления 3-11 и планирование таймера с помощью Базовой Основы

CFRunLoopRef runLoop = CFRunLoopGetCurrent();

CFRunLoopTimerContext context = {0, NULL, NULL, NULL, NULL};

CFRunLoopTimerRef timer = CFRunLoopTimerCreate(kCFAllocatorDefault, 0.1, 0.3, 0, 0,

                                        &myCFTimerCallback, &context);

CFRunLoopAddTimer(runLoop, timer, kCFRunLoopCommonModes);

Конфигурирование основанного на порте входного источника

И Какао и Базовая Основа обеспечивают основанные на порте объекты для передачи между потоками или между процессами. Следующие разделы показывают Вам, как установить коммуникацию порта с помощью нескольких различных типов портов.

- (void)launchThread

{

    NSPort* myPort = [NSMachPort port];

    if (myPort)

    {

        // This class handles incoming port messages.

        [myPort setDelegate:self];

        // Install the port as an input source on the current run loop.

        [[NSRunLoop currentRunLoop] addPort:myPort forMode:NSDefaultRunLoopMode];

        // Detach the thread. Let the worker release the port.

        [NSThread detachNewThreadSelector:@selector(LaunchThreadWithPort:)

               toTarget:[MyWorkerClass class] withObject:myPort];

    }

}

#define kCheckinMessage 100

// Handle responses from the worker thread.

- (void)handlePortMessage:(NSPortMessage *)portMessage

{

    unsigned int message = [portMessage msgid];

    NSPort* distantPort = nil;

    if (message == kCheckinMessage)

    {

        // Get the worker thread’s communications port.

        distantPort = [portMessage sendPort];

        // Retain and save the worker port for later use.

        [self storeDistantPort:distantPort];

    }

    else

    {

        // Handle other messages.

    }

}

+(void)LaunchThreadWithPort:(id)inData

{

    NSAutoreleasePool*  pool = [[NSAutoreleasePool alloc] init];

    // Set up the connection between this thread and the main thread.

    NSPort* distantPort = (NSPort*)inData;

    MyWorkerClass*  workerObj = [[self alloc] init];

    [workerObj sendCheckinMessage:distantPort];

    [distantPort release];

    // Let the run loop process things.

    do

    {

        [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode

                            beforeDate:[NSDate distantFuture]];

    }

    while (![workerObj shouldExit]);

    [workerObj release];

    [pool release];

}

// Worker thread check-in method

- (void)sendCheckinMessage:(NSPort*)outPort

{

    // Retain and save the remote port for future use.

    [self setRemotePort:outPort];

    // Create and configure the worker thread port.

    NSPort* myPort = [NSMachPort port];

    [myPort setDelegate:self];

    [[NSRunLoop currentRunLoop] addPort:myPort forMode:NSDefaultRunLoopMode];

    // Create the check-in message.

    NSPortMessage* messageObj = [[NSPortMessage alloc] initWithSendPort:outPort

                                         receivePort:myPort components:nil];

    if (messageObj)

    {

        // Finish configuring the message and send it immediately.

        [messageObj setMsgId:setMsgid:kCheckinMessage];

        [messageObj sendBeforeDate:[NSDate date]];

    }

}

NSPort* localPort = [[NSMessagePort alloc] init];

// Configure the object and add it to the current run loop.

[localPort setDelegate:self];

[[NSRunLoop currentRunLoop] addPort:localPort forMode:NSDefaultRunLoopMode];

// Register the port using a specific name. The name must be unique.

NSString* localPortName = [NSString stringWithFormat:@"MyPortName"];

[[NSMessagePortNameServer sharedInstance] registerPort:localPort

                     name:localPortName];

#define kThreadStackSize        (8 *4096)

OSStatus MySpawnThread()

{

    // Create a local port for receiving responses.

    CFStringRef myPortName;

    CFMessagePortRef myPort;

    CFRunLoopSourceRef rlSource;

    CFMessagePortContext context = {0, NULL, NULL, NULL, NULL};

    Boolean shouldFreeInfo;

    // Create a string with the port name.

    myPortName = CFStringCreateWithFormat(NULL, NULL, CFSTR("com.myapp.MainThread"));

    // Create the port.

    myPort = CFMessagePortCreateLocal(NULL,

                myPortName,

                &MainThreadResponseHandler,

                &context,

                &shouldFreeInfo);

    if (myPort != NULL)

    {

        // The port was successfully created.

        // Now create a run loop source for it.

        rlSource = CFMessagePortCreateRunLoopSource(NULL, myPort, 0);

        if (rlSource)

        {

            // Add the source to the current run loop.

            CFRunLoopAddSource(CFRunLoopGetCurrent(), rlSource, kCFRunLoopDefaultMode);

            // Once installed, these can be freed.

            CFRelease(myPort);

            CFRelease(rlSource);

        }

    }

    // Create the thread and continue processing.

    MPTaskID        taskID;

    return(MPCreateTask(&ServerThreadEntryPoint,

                    (void*)myPortName,

                    kThreadStackSize,

                    NULL,

                    NULL,

                    NULL,

                    0,

                    &taskID));

}

#define kCheckinMessage 100

// Main thread port message handler

CFDataRef MainThreadResponseHandler(CFMessagePortRef local,

                    SInt32 msgid,

                    CFDataRef data,

                    void* info)

{

    if (msgid == kCheckinMessage)

    {

        CFMessagePortRef messagePort;

        CFStringRef threadPortName;

        CFIndex bufferLength = CFDataGetLength(data);

        UInt8* buffer = CFAllocatorAllocate(NULL, bufferLength, 0);

        CFDataGetBytes(data, CFRangeMake(0, bufferLength), buffer);

        threadPortName = CFStringCreateWithBytes (NULL, buffer, bufferLength, kCFStringEncodingASCII, FALSE);

        // You must obtain a remote message port by name.

        messagePort = CFMessagePortCreateRemote(NULL, (CFStringRef)threadPortName);

        if (messagePort)

        {

            // Retain and save the thread’s comm port for future reference.

            AddPortToListOfActiveThreads(messagePort);

            // Since the port is retained by the previous function, release

            // it here.

            CFRelease(messagePort);

        }

        // Clean up.

        CFRelease(threadPortName);

        CFAllocatorDeallocate(NULL, buffer);

    }

    else

    {

        // Process other messages.

    }

    return NULL;

}

OSStatus ServerThreadEntryPoint(void* param)

{

    // Create the remote port to the main thread.

    CFMessagePortRef mainThreadPort;

    CFStringRef portName = (CFStringRef)param;

    mainThreadPort = CFMessagePortCreateRemote(NULL, portName);

    // Free the string that was passed in param.

    CFRelease(portName);

    // Create a port for the worker thread.

    CFStringRef myPortName = CFStringCreateWithFormat(NULL, NULL, CFSTR("com.MyApp.Thread-%d"), MPCurrentTaskID());

    // Store the port in this thread’s context info for later reference.

    CFMessagePortContext context = {0, mainThreadPort, NULL, NULL, NULL};

    Boolean shouldFreeInfo;

    Boolean shouldAbort = TRUE;

    CFMessagePortRef myPort = CFMessagePortCreateLocal(NULL,

                myPortName,

                &ProcessClientRequest,

                &context,

                &shouldFreeInfo);

    if (shouldFreeInfo)

    {

        // Couldn't create a local port, so kill the thread.

        MPExit(0);

    }

    CFRunLoopSourceRef rlSource = CFMessagePortCreateRunLoopSource(NULL, myPort, 0);

    if (!rlSource)

    {

        // Couldn't create a local port, so kill the thread.

        MPExit(0);

    }

    // Add the source to the current run loop.

    CFRunLoopAddSource(CFRunLoopGetCurrent(), rlSource, kCFRunLoopDefaultMode);

    // Once installed, these can be freed.

    CFRelease(myPort);

    CFRelease(rlSource);

    // Package up the port name and send the check-in message.

    CFDataRef returnData = nil;

    CFDataRef outData;

    CFIndex stringLength = CFStringGetLength(myPortName);

    UInt8* buffer = CFAllocatorAllocate(NULL, stringLength, 0);

    CFStringGetBytes(myPortName,

                CFRangeMake(0,stringLength),

                kCFStringEncodingASCII,

                0,

                FALSE,

                buffer,

                stringLength,

                NULL);

    outData = CFDataCreate(NULL, buffer, stringLength);

    CFMessagePortSendRequest(mainThreadPort, kCheckinMessage, outData, 0.1, 0.0, NULL, NULL);

    // Clean up thread data structures.

    CFRelease(outData);

    CFAllocatorDeallocate(NULL, buffer);

    // Enter the run loop.

    CFRunLoopRun();

}