MagicalRecord和dispatch_group

Question

我正在使用MagicalRecord，並且在我的一個視圖控制器中，數據源使用來自數據庫的數據提供。由於餵養過程包括多個步驟，我嘗試使用GCD來加速整個過程。 一般過程看起來像這樣。

在globalSummary中獲取訪問屬性後要完成的工作。 問題是應用程序掛在dispatch_group_wait。我嘗試將工作添加到該步驟，並在開始時工作，但是如果我一步一步地完成代碼，但添加更多工作，但如果讓它運行，則無法工作。

該方法有問題嗎？或者它與MagicalRecord在某些方面發生衝突？

- (NSArray *)dataSource 
{ 
    if (_dataSource == nil) { 

    _dataSource = [NSMutableArray array]; 
    NSManagedObjectContext *privateContext = [NSManagedObjectContext contextWithStoreCoordinator:[NSPersistentStoreCoordinator defaultStoreCoordinator]]; 

    GlobalSummary *globalSummary = [GlobalSummary insertInManagedObjectContext:privateContext]; // holds a bunch of fetched properties 

    dispatch_queue_t queue = dispatch_queue_create("de.berndrabe.dataSource", DISPATCH_QUEUE_CONCURRENT); 
    dispatch_group_t outerGroup = dispatch_group_create(); 

    __block SectionInfo *siPilotAircraft = nil; 
    if ([PilotAircraft countOfEntities]) { 
     dispatch_group_async(outerGroup, queue, ^{ 
      NSArray *frPilotAircraft = [PilotAircraft findAll]; 
      // do some processing an set SectionInfo variable 
     }); 
    } 

    __block SectionInfo *siMedicals = nil; 

    if ([PilotMedical countOfEntities]) { 
     dispatch_group_async(outerGroup, queue, ^{ 
      NSArray *frPilotMedical = [PilotMedical findAll]; 
     }); 
    } 

    // more working packets following the same patter 

    dispatch_group_wait(outerGroup, DISPATCH_TIME_FOREVER); 

    if (siPilotAircraft.countOfRows) { 
     [_dataSource addObject:siPilotAircraft]; 
    } 
    if (siMedicals.countOfRows) { 
     [_dataSource addObject:siMedicals]; 
    } 
} 

return _dataSource; 
} 

編輯： 使用[Entity findAllInContext:privateContext]讓我獲取所需要的記錄，但它仍然在現在一個實體:(

Answer 1

訪問故障時的關係我找到了解決我的問題，我被困。 這裏再次（在短）什麼我試圖完成。

任務 構建一個NSMutableArray這將充當用於UITableView 每個條目DataSource對象包括核心數據獲取和處理操作 parallelise工作和完成添加效果，確保訪問NSMutableArray調節 開始與數據源對象完成工作

問題 項的數據源中的對象的數量可以改變

這裏對後處理我。 'NSMutableArray'上的類別是確保訪問序列化的一種方便方法。 有了這個實現，你已經儘可能平行工作，你可以保存 寫

[self prepareDataSource]; [self.tableView reloadData];

無需擔心某些工作仍在進行中。

dispatch_queue_t queue = dispatch_queue_create("com.yourdomain.serializedAccess", DISPATCH_QUEUE_CONCURRENT); 

- (void)prepareDataSource 
{ 
    [self.dataSource removeAllObjects]; 

    dispatch_group_t group = dispatch_group_create(); 

    [self prepareWorkEntry1FromManagedObjectContext:self.privateContext forDataSource:self.dataSource group:group]; 
    [self prepareWorkEntry2FromManagedObjectContext:self.privateContext forDataSource:self.dataSource group:group]; 
    [self prepareWorkEntry3FromManagedObjectContext:self.privateContext forDataSource:self.dataSource group:group]; 

    dispatch_group_wait(group, DISPATCH_TIME_FOREVER); 
} 

- (void)prepareWorkEntry1FromManagedObjectContext:(NSManagedObjectContext *)context forDataSource:(NSMutableArray *)array group:(dispatch_group_t)group 
{ 
    __weak typeof(self) weakSelf = self; 

    dispatch_group_enter(group); 
    [context performBlock:^{ 
    Object *object = nil; 
     createObject(object); 

    if (object) { 
      [array serializedAddObject:object withQueue:weakSelf.queue group:group]; 
     } 
     else { 
      dispatch_group_leave(group); 
     } 
    }]; 
} 


@implementation NSMutableArray (ResourceProtection) 

- (void)serializedAddObject:(id)object withQueue:(dispatch_queue_t)queue group:(dispatch_group_t)group 
{ 
    if (group == NULL) { 
     dispatch_barrier_async(queue, ^{ 
      [self addObject:object]; 
     }); 
    } else { 
     dispatch_barrier_async(queue, ^{ 
      [self addObject:object]; 
      dispatch_group_leave(group); 
     }); 
    } 
} 

@end 

編輯： 至於ResourceProtection類別而言，你必須確保

1. dispatch_group_enter之前dispatch_group_leave
2. dispatch_group_enter和dispatch_group_leave平衡

這叫做是一個可觀察的同步寫入器方案，用於可變對象。

Answer 2

我想提出另一種使用助手庫的方法，它使異步任務更容易實現：它使用「Promises」作爲表示異步任務完成（或失敗）的手段。

基本上，代替完成塊，異步任務（方法在這種情況下）如下所示：

- (RXPromise*) doSomethingAsync; 

的最終結果分別故障可經由將在「註冊處理程序獲得「下方所示一樣：

- (void) foo 
{ 
    RXPromise* promise = [self doSomethingAsync]; 
    promise.then(<completion handler block>, <error handler block>); 
} 

或短，與填充有實際的代碼處理程序佔位符：

- (void) foo 
{ 
    [self doSomethingAsync] 
    .then(^id(id result) 
    { 
     // result is the eventual result of the asynchronous task 
     return nil; // return the result of the handler 

    }, id(NSError*error) 
    { 
     NSLog(@"ERROR: %@, error"); // the task failed with error 
     return nil; 
    }); 
} 

注意：處理程序本身在專用線程上執行（實際爲併發調度隊列）。 爲了同步處理程序中共享訪問一個可以明確地指定的處理程序將被執行調度隊列：

- (void) foo 
{ 
    [self doSomethingAsync] 
    .thenOn(dispatch_get_main_queue()), ^id(id result) 
    { 
     // Here, we are executing on the main thread 
     // result is the eventual result of the asynchronous task 
     return nil; // return the result of the handler 

    }, id(NSError*error) 
    { 
     // Here, we are executing on the main thread 
     NSLog(@"ERROR: %@, error"); // the task failed with error 
     return nil; 
    }); 
} 

注意，在[self doSomethingAsync]執行的異步任務可以擁有自己的私人線程（或隊列）執行。

的多個異步任務「延續」，可以很容易地完成：

task1() 
.then(^id(id result1{ 
    return task2(result1); 
}, nil) 
.then(^id(id result2) { 
    return task3(result2); 
}, nil) 
.then(nil, ^id(NSError*error) 
    NSLog(@"Something went wrong in task1 or task2 or task3: %@", error); 
    return nil; 
); 

這個簡短的介紹後，您可以按如下解決您的問題：

定義你的異步任務，它會返回一個RXPromise：

- (RXPromise*) prepareWorkEntry1FromManagedObjectContext:(NSManagedObjectContext *)context; 
- (RXPromise*) prepareWorkEntry2FromManagedObjectContext:(NSManagedObjectContext *)context; 
- (RXPromise*) prepareWorkEntry3FromManagedObjectContext:(NSManagedObjectContext *)context; 


- (RXPromise*) prepareWorkEntry1FromManagedObjectContext:(NSManagedObjectContext *)context 
{ 
    RXPromise* promise = [RXPromise new]; 
    [context performBlock:^{ 
     Object *object = nil; 
     createObject(object); 

     if (object) { 
      // success 
      [promise fulfillWithValue:object]; 
     } 
     else { 
      // failure 
      [promise rejectWithReason:@"object creation failed"]; 
     } 
    }]; 

    return promise; 
} 

同樣，執行其他任務。

合併結果的處理：

- (void) foo 
{ 
    [self prepareWorkEntry1FromManagedObjectContext:moc] 
    .thenOn(self.sync_queue, (^id(id object)) { 
     [self.dataSourceArray addObject:object]; 
     return @"Finished 1"; 
    }, nil); 

    [self prepareWorkEntry2FromManagedObjectContext:moc] 
    .thenOn(self.sync_queue, (^id(id object)) { 
     [self.dataSourceArray addObject:object]; 
     return @"Finished 2"; 
    }, nil); 

    [self prepareWorkEntry3FromManagedObjectContext:moc] 
    .thenOn(self.sync_queue, (^id(id object)) { 
     [self.dataSourceArray addObject:object]; 
     return @"Finished 3"; 
    }, nil); 

} 

注意，dataSourceArray將在專用sync_queue訪問。這應該是一個串行調度隊列。

另請注意，該方法foo是有效異步的。

還有爲「異步等待」，直到一些異步任務已經完成的可能性：我這個庫，你可以在這裏找到的作者

- (void) foo { 

    NSArray* promises = @[ 

    [self prepareWorkEntry1FromManagedObjectContext:moc] 
    .thenOn(self.sync_queue, (^id(id object)) { 
     [self.dataSourceArray addObject:object]; 
     return @"Finished 1"; 
    }, nil), 

    [self prepareWorkEntry2FromManagedObjectContext:moc] 
    .thenOn(self.sync_queue, (^id(id object)) { 
     [self.dataSourceArray addObject:object]; 
     return @"Finished 2"; 
    }, nil), 

    [self prepareWorkEntry3FromManagedObjectContext:moc] 
    .thenOn(self.sync_queue, (^id(id object)) { 
     [self.dataSourceArray addObject:object]; 
     return @"Finished 3"; 
    }, nil) 

    ]; 

    [RXPromise all:promises] 
    .then(^id(id arrayOfPromises){ 
     // all tasks *and its handlers* finished. 
     ... 
     return nil; 
    }, nil); 
} 

：RXPromise。