Используя dispatch_sync в Grand Central Dispatch

Ответ 1

Вы используете его, когда хотите выполнить блок и ждать результатов.

Одним из примеров этого является шаблон, в котором вы используете очередь отправки вместо блокировок для синхронизации. Например, предположим, что у вас есть общий NSMutableArray a, с доступом, опосредованным диспетчерской очередью q. Фоновый поток может быть добавлен к массиву (async), в то время как поток переднего плана вытаскивает первый элемент (синхронно):

NSMutableArray *a = [[NSMutableArray alloc] init];
// All access to `a` is via this dispatch queue!
dispatch_queue_t q = dispatch_queue_create("com.foo.samplequeue", NULL);

dispatch_async(q, ^{ [a addObject:something]; }); // append to array, non-blocking

__block Something *first = nil;            // "__block" to make results from block available
dispatch_sync(q, ^{                        // note that these 3 statements...
        if ([a count] > 0) {               // ...are all executed together...
             first = [a objectAtIndex:0];  // ...as part of a single block...
             [a removeObjectAtIndex:0];    // ...to ensure consistent results
        }
});

Ответ 2

Сначала поймите своего брата dispatch_async

//Do something
dispatch_async(queue, ^{
    //Do something else
});
//Do More Stuff

Вы используете dispatch_async для создания нового потока. Когда вы это сделаете, текущий поток не остановится. Это означает, что //Do More Stuff может выполняться до //Do something else finish

Что произойдет, если вы хотите остановить текущий поток?

Вы не используете отправку вообще. Просто напишите код обычно

//Do something
//Do something else
//Do More Stuff

Теперь скажите, что вы хотите что-то сделать в потоке DIFFERENT, и все же подождите, как будто и убедитесь, что файлы выполняются последовательно.

Есть много причин для этого. Обновление пользовательского интерфейса, например, выполняется в основном потоке.

Что вы используете dispatch_sync

//Do something
dispatch_sync(queue, ^{
    //Do something else
});
//Do More Stuff

Здесь вы получили //Do something //Do something else и //Do More Stuff, выполняемые последовательно, хотя //Do something else выполняется в другом потоке.

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

Следовательно, dispatch_sync редко используется. Но это там. Я лично никогда не использовал это. Почему бы не попросить пример кода или проекта, который использует dispatch_sync.

Ответ 3

dispatch_sync семантически эквивалентен традиционной блокировке мьютекса.

dispatch_sync(queue, ^{
    //access shared resource
});

работает так же, как

pthread_mutex_lock(&lock);
//access shared resource
pthread_mutex_unlock(&lock);

Ответ 4

Если вы хотите, чтобы некоторые примеры практического использования рассмотрели мой вопрос:

Как разрешить этот тупик, который происходит ocassionally?

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

Мне нужно dispatch_sync, потому что некоторый код нужно делать в основном потоке, который является другим потоком, чем тот, где выполняется код.

Итак, в основном, если вы хотите, чтобы код 1. Действуйте как обычно. Вы не хотите беспокоиться о гоночных условиях. Вы хотите убедиться, что код был завершен, прежде чем двигаться дальше. 2. Сделано в другой теме

используйте dispatch_sync.

Если 1 нарушено, используйте dispatch_async. Если 2 нарушено, просто напишите код, как обычно.

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

Итак, вот код:

+(NSManagedObjectContext *)managedObjectContext {


    NSThread *thread = [NSThread currentThread];
    //BadgerNewAppDelegate *delegate = [BNUtilitiesQuick appDelegate];
    //NSManagedObjectContext *moc = delegate.managedObjectContext;

    if ([thread isMainThread]) {
        //NSManagedObjectContext *moc = [self managedObjectContextMainThread];
        return [self managedObjectContextMainThread];
    }
    else{
        dispatch_sync(dispatch_get_main_queue(),^{
            [self managedObjectContextMainThread];//Access it once to make sure it there
        });
    }

    // a key to cache the context for the given thread
    NSMutableDictionary *managedObjectContexts =[self thread].managedObjectContexts;

    @synchronized(self)
    {
        if ([managedObjectContexts objectForKey:[self threadKey]] == nil ) {
            NSManagedObjectContext *threadContext = [[NSManagedObjectContext alloc] initWithConcurrencyType:NSPrivateQueueConcurrencyType];
            threadContext.parentContext = [self managedObjectContextMainThread];
            //threadContext.persistentStoreCoordinator= [self persistentStoreCoordinator]; //moc.persistentStoreCoordinator;//  [moc persistentStoreCoordinator];
            threadContext.mergePolicy = NSMergeByPropertyObjectTrumpMergePolicy;
            [managedObjectContexts setObject:threadContext forKey:[self threadKey]];
        }
    }


    return [managedObjectContexts objectForKey:[self threadKey]];
}

Ответ 5

Дэвид Гелхар не сказал, что его пример будет работать только потому, что он спокойно создал очередную очередь (передал NULL в dispatch_queue_create, что равно DISPATCH_QUEUE_SERIAL).

Если вы хотите создать параллельную очередь (чтобы получить всю многопоточность), его код приведет к сбою из-за мутации NSArray (addObject:) во время мутации (removeObjectAtIndex:) или даже плохой доступ (диапазон NSArray выходит за рамки). В этом случае мы должны использовать барьер для обеспечения эксклюзивного доступа к NSArray, пока оба блока работают. Он не только исключает все другие записи в NSArray во время его запуска, но также исключает все остальные чтения, делая безопасную модификацию.

Пример для параллельной очереди должен выглядеть следующим образом:

NSMutableArray *a = [[NSMutableArray alloc] init];
// All access to `a` is via this concurrent dispatch queue!
dispatch_queue_t q = dispatch_queue_create("com.foo.samplequeue", DISPATCH_QUEUE_CONCURRENT);

// append to array concurrently but safely and don't wait for block completion
dispatch_barrier_async(q, ^{ [a addObject:something]; }); 

__block Something *first = nil;
// pop 'Something first' from array concurrently and safely but wait for block completion...
dispatch_barrier_sync(q, ^{                        
        if ([a count] > 0) {               
             first = [a objectAtIndex:0];  
             [a removeObjectAtIndex:0];    
        }
});
// ... then here you get your 'first = [a objectAtIndex:0];' due to synchronised dispatch.
// If you use async instead of sync here, then first will be nil.

Ответ 6

dispatch_sync в основном используется внутри блока dispatch_async для выполнения некоторых операций с основным потоком (например, update ui).

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    //Update UI in main thread
    dispatch_sync(dispatch_get_main_queue(), ^{
      self.view.backgroundColor = color;
    });
});

Ответ 7

Здесь показан реалистичный пример на полпути. У вас есть 2000 zip файлов, которые вы хотите анализировать параллельно. Но zip-библиотека не является потокобезопасной. Поэтому вся работа, касающаяся библиотеки zip, переходит в очередь unzipQueue. (Пример находится в Ruby, но все вызовы отображаются непосредственно в библиотеке C. "применить", например, карты на dispatch_apply (3))

#!/usr/bin/env macruby -w

require 'rubygems'
require 'zip/zipfilesystem'

@unzipQueue = Dispatch::Queue.new('ch.unibe.niko.unzipQueue')
def extractFile(n)
    @unzipQueue.sync do
        Zip::ZipFile.open("Quelltext.zip") {   |zipfile|
            sourceCode = zipfile.file.read("graph.php")
        }
    end
end

Dispatch::Queue.concurrent.apply(2000) do |i|
   puts i if i % 200 == 0
   extractFile(i)
end

Ответ 8

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

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

Пример блока:

dispatch_queue_t myQueue = dispatch_queue_create("my.dispatch.q", 0);
dispatch_async(myQueue,
^{

    //  Do some nasty CPU intensive processing, load file whatever

         if (somecondition in the nasty CPU processing stuff)
         {
             //  Do stuff
             dispatch_sync(dispatch_get_main_queue(),^{/* Do Stuff that affects UI Here */});
         }

 });