синхронизация отправки и асинхронная отправка в главной очереди

Я считаю, что Райан находится на правильном пути: просто слишком много потоков порождается, когда проект имеет 1500 файлов (количество, с которым я решил протестировать.)

Итак, я переработал код выше, чтобы работать следующим образом:

- (void) establishImportLinksForFilesInProject:(LPProject *)aProject
{
        dispatch_queue_t taskQ = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

     dispatch_async(taskQ, 
     ^{

     // Create a new Core Data Context on this thread using the same persistent data store    
     // as the main thread. Pass the objectID of aProject to access the managedObject
     // for that project on this thread's context:

     NSManagedObjectID *projectID = [aProject objectID];

     for (LPFile *fileToCheck in [backgroundContext objectWithID:projectID] memberFiles])
     {
        if (//Some condition is met)
        {
                // Here, we do the scanning for @import statements. 
                // When we find a valid one, we put the whole path to the 
                // imported file into an array called 'verifiedImports'. 

                // Pass this ID to main thread in dispatch call below to access the same
                // file in the main thread's context
                NSManagedObjectID *fileID = [fileToCheck objectID];


                // go back to the main thread and update the model 
                // (Core Data is not thread-safe.)
                dispatch_async(dispatch_get_main_queue(), 
                ^{
                    for (NSString *import in verifiedImports)
                    {  
                       LPFile *targetFile = [mainContext objectWithID:fileID];
                       // Add the relationship to targetFile. 
                    }
                 });//end block
         }
    }
    // Easy way to tell when we're done processing all files.
    // Could add a dispatch_async(main_queue) call here to do something like UI updates, etc

    });//end block
    }

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

эта реализация по существу устанавливает" последовательную " очередь, как предложил Райан(цикл for является его последовательной частью), но с одним преимуществом: когда цикл for заканчивается, мы заканчиваем обработку всех файлов, и мы можем просто вставить блок dispatch_async (main_queue), чтобы делать все, что мы хотим. Это очень хороший способ сказать, когда задача параллельной обработки завершена, и этого не было в моем старая версия.

недостатком здесь является то, что это немного сложнее работать с основными данными на нескольких потоках. Но этот подход кажется пуленепробиваемым для проектов с 5 000 файлами (что является самым высоким, который я тестировал.)

Я думаю, что это более легко разобраться со схемой:

для ситуации, описанной автором:

|taskQ| ***********начало|

/ dispatch_1 ***********|---------

/ dispatch_2 *************|---------

.

/ dispatch_n ***************************|----------

/ главная очередь (синхронизация) / * * начало отправки в главная|

*************************|--dispatch_1--|--dispatch_2--|--dispatch3--|*****************************|--dispatch_n|,

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