为什么主队列上的GCD dispatch_async会导致后台队列出现死锁？

Question

I am creating a serial background queue like this:

@property (nonatomic, strong) dispatch_queue_t assetCreationQueue;

// in init...
_assetCreationQueue = dispatch_queue_create("com.mycompany.assetCreationQueue", DISPATCH_QUEUE_SERIAL);

Then I enumerate ALAsset objects in the background like this:

[group enumerateAssetsUsingBlock:^(ALAsset *asset, NSUInteger index, BOOL *stop){
    if (asset){
        dispatch_async(weakSelf.assetCreationQueue, ^{
            ALAssetRepresentation *assetRepresentation = [asset defaultRepresentation];
            NSURL *url = [assetRepresentation url];
            if (url) {
                AVURLAsset *avAsset = [[AVURLAsset alloc] initWithURL:url options:nil];

                // This NSLog fires! avAsset exists.
                NSLog(@"AVURLAsset %@", avAsset);

                dispatch_async(dispatch_get_main_queue(), ^{
                    // This NSLog NEVER fires.
                    // Also tried dispatch_sync.
                    NSLog(@"add to assets array on main queue");
                    [weakSelf.assets insertObject:avAsset atIndex:0];
                });
            }
        });
    }
}];

The assets array property is defined as:

@property (nonatomic, strong) NSMutableArray *assets;

When I try dispatch_sync(dispatch_get_main_queue(), ^{ I only get ONE NSLog(@"AVURLAsset %@", avAsset); in the console and it indicates that dispatch_sync is causing a deadlock.

But how can I find out why? I don't see where. The assetCreationQueue is a background queue and I have to operate on the array only on the main queue.

EDIT: Here is a much more simplified test which also fails:

[group enumerateAssetsUsingBlock:^(ALAsset *asset, NSUInteger index, BOOL *stop){
    if (asset){
        dispatch_async(weakSelf.assetCreationQueue, ^{
            if ([NSThread isMainThread]) {
                NSLog(@"already main thread"); // gets called often!!
            } else {
                dispatch_async(dispatch_get_main_queue(), ^{
                    NSLog(@"dispatch async on main queue"); // never gets called!!
                });
            }
        });
     }
}];

So what I don't understand is: Why am I already on the main thread even though I call dispatch_async(weakSelf.assetCreationQueue . It can only lead to evil conclusion: The queue I create is NOT a background queue:

_assetCreationQueue = dispatch_queue_create("com.mycompany.assetCreationQueue", DISPATCH_QUEUE_SERIAL);

Why?

Answer 1

(Not really an answer, but I want to provide enough information to move forward.)

I've tried a very simple program, and this doesn't reproduce at all. I get many calls to "dispatch async on main queue" and no calls to "already main thread" (the opposite of what you're expecting). I'm running this on an iPhone 5. Complete code:

#import "AppDelegate.h"
@import AssetsLibrary;

@interface AppDelegate ()
@property (nonatomic, strong) dispatch_queue_t assetCreationQueue;
@end

@implementation AppDelegate

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
  self.assetCreationQueue = dispatch_queue_create("com.mycompany.assetCreationQueue", DISPATCH_QUEUE_SERIAL);

  ALAssetsLibrary* library = [[ALAssetsLibrary alloc] init];
  AppDelegate __weak *weakSelf = self;
  [library enumerateGroupsWithTypes:ALAssetsGroupAll
                         usingBlock:^(ALAssetsGroup *group, BOOL *stop) {
                           [group enumerateAssetsUsingBlock:^(ALAsset *asset, NSUInteger index, BOOL *stop){
                             if (asset){
                               dispatch_async(weakSelf.assetCreationQueue, ^{
                                 if ([NSThread isMainThread]) {
                                   NSLog(@"already main thread"); // gets called often!!
                                 } else {
                                   dispatch_async(dispatch_get_main_queue(), ^{
                                     NSLog(@"dispatch async on main queue"); // never gets called!!
                                   });
                                 }
                               });
                             }
                           }];
                         }
                       failureBlock:nil];
  return YES;
}
@end

Note that the use of weakSelf here is unnecessary and dangerous (but if this were the problem, you'd be crashing). You only need weakSelf if the block is going to be stored in a property of an object that self retains. It is not necessary or even desired for short-lived blocks like this. The way you've used it, if the owning object deallocated in the middle of the enumeration (which it can), weakSelf would become nil, weakSelf.assetCreationQueue would be nil , and dispatch_async() would crash. (But again, this is unlikely the cause of your issue, since it should crash.)