Core Data private queue deadlock

Question

I have a background thread doing some processing, and saving to Core Data. In my app delegate's applicationShouldTerminate, I wait on a semaphore which is released when the background thread completes its work. This is to avoid killing the thread in the middle of its work and leaving things in an inconsistent state.

Unfortunately, this causes a deadlock. Here is how the background job operates:

_context = [[NSManagedObjectContext alloc] initWithConcurrencyType:NSPrivateQueueConcurrencyType];
[_context setParentContext:_parentContext];

[_context performBlock:
^{
    // ... long-running task here ...

    NSError * error;
    [_context save:&error]; // deadlock here if main thread is waiting on semaphore

    // ... release semaphore here ...
}];

If the user quits the app while the background thread is still working, it deadlocks. The problem seems to be that [_context save:&error] is calling dispatch_sync (or an equivalent) into the main thread - but the main thread is already waiting for this thread to release the semaphore, and so isn't able to run the block.

Since a child context save appears to block on the main thread, how can this pattern (main thread waiting for child to complete and save its context) be achieved?

Main thread:

#0  0x00007fff882e96c2 in semaphore_wait_trap ()
#1  0x00007fff876264c2 in _dispatch_semaphore_wait_slow ()
#2  0x00000001001157fb in +[IndxCore waitForBackgroundJobs] at /Users/mspong/dev/Indx/IndxCore/IndxCore/IndxCore.m:48
#3  0x00000001000040c6 in -[RHAppDelegate applicationShouldTerminate:] at /Users/mspong/dev/Indx/Indx/Indx/RHAppDelegate.m:324
#4  0x00007fff9071a48f in -[NSApplication _docController:shouldTerminate:] ()
#5  0x00007fff9071a39e in __91-[NSDocumentController(NSInternal) _closeAllDocumentsWithDelegate:shouldTerminateSelector:]_block_invoke_0 ()
#6  0x00007fff9071a23a in -[NSDocumentController(NSInternal) _closeAllDocumentsWithDelegate:shouldTerminateSelector:] ()
(snip)
#17 0x00007fff9048e656 in NSApplicationMain ()
#18 0x0000000100001e72 in main at /Users/mspong/dev/Indx/Indx/Indx/main.m:13
#19 0x00007fff8c4577e1 in start ()

Background thread:

#0  0x00007fff882e96c2 in semaphore_wait_trap ()
#1  0x00007fff87627c6e in _dispatch_thread_semaphore_wait ()
#2  0x00007fff87627ace in _dispatch_barrier_sync_f_slow ()
#3  0x00007fff8704a78c in _perform ()
#4  0x00007fff8704a5d2 in -[NSManagedObjectContext(_NestedContextSupport) executeRequest:withContext:error:] ()
#5  0x00007fff8702c278 in -[NSManagedObjectContext save:] ()
#6  0x000000010011640d in __22-[Indexer updateIndex]_block_invoke_0 at /Users/mspong/dev/Indx/IndxCore/IndxCore/Indexer/Indexer.m:70
#7  0x00007fff87079b4f in developerSubmittedBlockToNSManagedObjectContextPerform_privateasync ()
#8  0x00007fff876230fa in _dispatch_client_callout ()
#9  0x00007fff876244c3 in _dispatch_queue_drain ()
#10 0x00007fff87624335 in _dispatch_queue_invoke ()
#11 0x00007fff87624207 in _dispatch_worker_thread2 ()
#12 0x00007fff88730ceb in _pthread_wqthread ()
#13 0x00007fff8871b1b1 in start_wqthread ()

That reminds me of this issue: http://stackoverflow.com/questions/11786436/core-data-nested-managed-object-contexts-and-frequent-deadlocks-freezes/11900851#11900851 — Martin R, Sep 16 '12 at 15:06
As a workaround you could use `dispatch_semaphore_wait` with a timeout of 1 second in a loop, until it succeeds. — Martin R, Sep 16 '12 at 15:10
I'd been considering such workarounds - but I need to return from `applicationShouldTerminate` immediately to make any of this work. Would you suggest returning `NSTerminateCancel`, and then initiate another quit once I acquire the semaphore? Seems like a silly workaround for a basic problem that Apple *must* have considered. — Xtapolapocetl, Sep 16 '12 at 15:18
I have no practical experience with this, but according to the documentation of `applicationShouldTerminate:`, it is perfectly OK to return `NSTerminateCancel`. Your background thread could call `replyToApplicationShouldTerminate:` when the saving is finished (perhaps wrapped into `performSelectorOnMainThread`). Then you don't need the semaphore at all. — Martin R, Sep 16 '12 at 15:28
Aha! I was unaware of `NSTerminateLater` and `replyToApplicationShouldTerminate`. That seems to solve my problem nicely. I'll still need the semaphore (there may be multiple background jobs running), but this gives me a framework I can work with. Can you post your response as an answer so I can mark it as accepted? — Xtapolapocetl, Sep 16 '12 at 15:34

Martin R · Accepted Answer · 2012-09-16T15:45:03.290

4

In applicationShouldTerminate: you can return NSTerminateLater to delay the termination until the background context has finished the save operation.

When the saving is done, you call

[[NSApplication sharedApplication] replyToApplicationShouldTerminate:YES];

to quit the application.

edited Sep 16 '12 at 15:45

answered Sep 16 '12 at 15:39

Martin R

529,903
94
1,240
1,382

A correction - `applicationShouldTerminate:` needs to return `NSTerminateLater` to make this work. But this is the answer. Thanks! – Xtapolapocetl Sep 16 '12 at 15:41
@Xtapolapocetl: You are right, I will correct it in the answer. – Martin R Sep 16 '12 at 15:44

Core Data private queue deadlock

1 Answers1