использование dispatch_sync в Grand Central Dispatch

Question

Кто-нибудь может объяснить с очень ясными случаями использования, для чего предназначение dispatch_sync в GCD? Я не могу понять, где и почему я должен использовать это.

Спасибо!

Answer 1

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

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

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

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

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

//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.

Answer 2

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

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

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
        }
});

Answer 3

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

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

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

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

Answer 4

Дэвид Гелхар оставил недосказанным, что его пример будет работать только потому, что он спокойно создал последовательную очередь (передал 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.

Answer 5

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

Как мне разрешить этот тупик, который иногда возникает?

Я решаю его с помощьюобеспечение того, чтобы мой главный 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's 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]];
}

Answer 6

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

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;
    });
});

Answer 7

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

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

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

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 */});
         }

 });

Answer 8

Вот наполовину реалистичный пример. У вас есть 2000 zip-файлов, которые вы хотите анализировать параллельно. Но библиотека zip не является поточно-ориентированной. Поэтому вся работа, касающаяся библиотеки zip, попадает в очередь unzipQueue. (Пример написан на Ruby, но все вызовы сопоставляются непосредственно с библиотекой C. "apply", например, сопоставляет 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