Merge pull request SDWebImage#3766 from dreampiggy/bugfix/uiview_webcache_sdcallbackqueue

Deprecate dispatch_main_async_safe, introduce two more policy `.safeAsyncMainThread` (for UIKit diffable data source) and `.safeAsyncMainQueue`  (for most common cases)

Author: dreampiggy

SDWebImage/Core/SDCallbackQueue.h

@@ -16,28 +16,35 @@ typedef NS_ENUM(NSUInteger, SDCallbackPolicy) {
     /// Follow async/sync using the correspond `dispatch_async`/`dispatch_sync` to dispatch block on queue
     SDCallbackPolicyDispatch = 1,
     /// Ignore any async/sync and just directly invoke `block` in current queue (without `dispatch_async`/`dispatch_sync`)
-    SDCallbackPolicyInvoke = 2
+    SDCallbackPolicyInvoke = 2,
+    /// Ensure callback in main queue (no gurantee on main thread). Do `dispatch_async` if the current queue is not main queue; else do invoke `block`. Never use `dispatch_sync`, suitable for general UI-related code
+    SDCallbackPolicySafeAsyncMainQueue = 3,
+    /// Ensure callback in main thread. Do `dispatch_async` if the `NSThread.isMainTrhead == true` ; else do invoke `block`. Never use `dispatch_sync`, suitable for special UI-related code
+    SDCallbackPolicySafeAsyncMainThread = 4,
 };
 
 /// SDCallbackQueue is a wrapper used to control how the completionBlock should perform on queues, used by our `Cache`/`Manager`/`Loader`.
 /// Useful when you call SDWebImage in non-main queue and want to avoid it callback into main queue, which may cause issue.
 @interface SDCallbackQueue : NSObject
 
-/// The shared main queue. This is the default value, has the same effect when passing `nil` to `SDWebImageContextCallbackQueue`
+/// The main queue. This is the default value, has the same effect when passing `nil` to `SDWebImageContextCallbackQueue`
+/// The policy defaults to `SDCallbackPolicySafeAsyncMainQueue`
 @property (nonnull, class, readonly) SDCallbackQueue *mainQueue;
 
 /// The caller current queue. Using `dispatch_get_current_queue`. This is not a dynamic value and only keep the first call time queue.
+/// The policy defaults to `SDCallbackPolicySafeExecute`
 @property (nonnull, class, readonly) SDCallbackQueue *currentQueue;
 
 /// The global concurrent queue (user-initiated QoS). Using `dispatch_get_global_queue`.
+/// The policy defaults to `SDCallbackPolicySafeExecute`
 @property (nonnull, class, readonly) SDCallbackQueue *globalQueue;
 
-/// The current queue's callback policy, defaults to `SDCallbackPolicySafeExecute`, which behaves like the old macro  `dispatch_main_async_safe`
-@property (assign, readwrite) SDCallbackPolicy policy;
+/// The current queue's callback policy.
+@property (nonatomic, assign, readwrite) SDCallbackPolicy policy;
 
 - (nonnull instancetype)init NS_UNAVAILABLE;
 + (nonnull instancetype)new  NS_UNAVAILABLE;
-/// Create the callback queue with a GCD queue
+/// Create the callback queue with a GCD queue. The policy defaults to `SDCallbackPolicySafeExecute`
 /// - Parameter queue: The GCD queue, should not be NULL
 - (nonnull instancetype)initWithDispatchQueue:(nonnull dispatch_queue_t)queue NS_DESIGNATED_INITIALIZER;
 

SDWebImage/Core/SDCallbackQueue.m

@@ -15,31 +15,40 @@ @interface SDCallbackQueue ()
 
 @end
 
-static void * SDCallbackQueueKey = &SDCallbackQueueKey;
-static void SDReleaseBlock(void *context) {
-    CFRelease(context);
-}
-
-static void SDSafeExecute(SDCallbackQueue *callbackQueue, dispatch_block_t _Nonnull block, BOOL async) {
-    // Extendc gcd queue's life cycle
-    dispatch_queue_t queue = callbackQueue.queue;
-    // Special handle for main queue label only (custom queue can have the same label)
-    const char *label = dispatch_queue_get_label(queue);
-    if (label && label == dispatch_queue_get_label(dispatch_get_main_queue())) {
+static inline void SDSafeMainQueueAsync(dispatch_block_t _Nonnull block) {
+    if (NSThread.isMainThread) {
+        // Match exists `dispatch_main_async_safe` behavior
         const char *currentLabel = dispatch_queue_get_label(DISPATCH_CURRENT_QUEUE_LABEL);
-        if (label == currentLabel) {
+        const char *mainLabel = dispatch_queue_get_label(dispatch_get_main_queue());
+        if (mainLabel == currentLabel) {
             block();
             return;
         }
     }
-    // Check specific to detect queue equal
-    void *specific = dispatch_queue_get_specific(queue, SDCallbackQueueKey);
-    if (specific && CFGetTypeID(specific) == CFUUIDGetTypeID()) {
-        void *currentSpecific = dispatch_get_specific(SDCallbackQueueKey);
-        if (currentSpecific && CFGetTypeID(currentSpecific) == CFUUIDGetTypeID() && CFEqual(specific, currentSpecific)) {
-            block();
-            return;
-        }
+    dispatch_async(dispatch_get_main_queue(), block);
+}
+
+static inline void SDSafeMainThreadAsync(dispatch_block_t _Nonnull block) {
+    if (NSThread.isMainThread) {
+        block();
+    } else {
+        dispatch_async(dispatch_get_main_queue(), block);
+    }
+}
+
+static void SDSafeExecute(dispatch_queue_t queue, dispatch_block_t _Nonnull block, BOOL async) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+    dispatch_queue_t currentQueue = dispatch_get_current_queue();
+#pragma clang diagnostic pop
+    if (queue == currentQueue) {
+        block();
+        return;
+    }
+    // Special handle for main queue only
+    if (NSThread.isMainThread && queue == dispatch_get_main_queue()) {
+        block();
+        return;
     }
     if (async) {
         dispatch_async(queue, block);
@@ -54,19 +63,15 @@ - (instancetype)initWithDispatchQueue:(dispatch_queue_t)queue {
     self = [super init];
     if (self) {
         NSCParameterAssert(queue);
-        CFUUIDRef UUID = CFUUIDCreate(kCFAllocatorDefault);
-        dispatch_queue_set_specific(queue, SDCallbackQueueKey, (void *)UUID, SDReleaseBlock);
         _queue = queue;
+        _policy = SDCallbackPolicySafeExecute;
     }
     return self;
 }
 
 + (SDCallbackQueue *)mainQueue {
-    static dispatch_once_t onceToken;
-    static SDCallbackQueue *queue;
-    dispatch_once(&onceToken, ^{
-        queue = [[SDCallbackQueue alloc] initWithDispatchQueue:dispatch_get_main_queue()];
-    });
+    SDCallbackQueue *queue = [[SDCallbackQueue alloc] initWithDispatchQueue:dispatch_get_main_queue()];
+    queue->_policy = SDCallbackPolicySafeAsyncMainQueue;
     return queue;
 }
 
@@ -86,33 +91,45 @@ + (SDCallbackQueue *)globalQueue {
 - (void)sync:(nonnull dispatch_block_t)block {
     switch (self.policy) {
         case SDCallbackPolicySafeExecute:
-            SDSafeExecute(self, block, NO);
+            SDSafeExecute(self.queue, block, NO);
             break;
         case SDCallbackPolicyDispatch:
             dispatch_sync(self.queue, block);
             break;
         case SDCallbackPolicyInvoke:
             block();
             break;
+        case SDCallbackPolicySafeAsyncMainQueue:
+            SDSafeMainQueueAsync(block);
+            break;
+        case SDCallbackPolicySafeAsyncMainThread:
+            SDSafeMainThreadAsync(block);
+            break;
         default:
-            SDSafeExecute(self, block, NO);
+            NSCAssert(NO, @"unexpected policy %tu", self.policy);
             break;
     }
 }
 
 - (void)async:(nonnull dispatch_block_t)block {
     switch (self.policy) {
         case SDCallbackPolicySafeExecute:
-            SDSafeExecute(self, block, YES);
+            SDSafeExecute(self.queue, block, YES);
             break;
         case SDCallbackPolicyDispatch:
             dispatch_async(self.queue, block);
             break;
         case SDCallbackPolicyInvoke:
             block();
             break;
+        case SDCallbackPolicySafeAsyncMainQueue:
+            SDSafeMainQueueAsync(block);
+            break;
+        case SDCallbackPolicySafeAsyncMainThread:
+            SDSafeMainThreadAsync(block);
+            break;
         default:
-            SDSafeExecute(self, block, YES);
+            NSCAssert(NO, @"unexpected policy %tu", self.policy);
             break;
     }
 }

SDWebImage/Core/SDWebImageCompat.h

@@ -98,4 +98,5 @@
     } else {\
         dispatch_async(dispatch_get_main_queue(), block);\
     }
+#pragma clang deprecated(dispatch_main_async_safe, "Use SDCallbackQueue instead")
 #endif

SDWebImage/Core/UIView+WebCache.m

@@ -13,6 +13,7 @@
 #import "SDInternalMacros.h"
 #import "SDWebImageTransitionInternal.h"
 #import "SDImageCache.h"
+#import "SDCallbackQueue.h"
 
 const int64_t SDWebImageProgressUnitCountUnknown = 1LL;
 
@@ -108,7 +109,7 @@ - (void)setSd_imageProgress:(NSProgress *)sd_imageProgress {
         mutableContext[SDWebImageContextCustomManager] = nil;
         context = [mutableContext copy];
     }
-    
+    SDCallbackQueue *queue = context[SDWebImageContextCallbackQueue];
     BOOL shouldUseWeakCache = NO;
     if ([manager.imageCache isKindOfClass:SDImageCache.class]) {
         shouldUseWeakCache = ((SDImageCache *)manager.imageCache).config.shouldUseWeakMemoryCache;
@@ -121,9 +122,9 @@ - (void)setSd_imageProgress:(NSProgress *)sd_imageProgress {
             // in the future the weak cache feature may be re-design or removed
             [((SDImageCache *)manager.imageCache) imageFromMemoryCacheForKey:key];
         }
-        dispatch_main_async_safe(^{
+        [(queue ?: SDCallbackQueue.mainQueue) async:^{
             [self sd_setImage:placeholder imageData:nil basedOnClassOrViaCustomSetImageBlock:setImageBlock cacheType:SDImageCacheTypeNone imageURL:url];
-        });
+        }];
     }
 
     id <SDWebImageOperation> operation = nil;
@@ -138,7 +139,7 @@ - (void)setSd_imageProgress:(NSProgress *)sd_imageProgress {
 
 #if SD_UIKIT || SD_MAC
         // check and start image indicator
-        [self sd_startImageIndicator];
+        [self sd_startImageIndicatorWithQueue:queue];
         id<SDWebImageIndicator> imageIndicator = self.sd_imageIndicator;
 #endif
 
@@ -176,7 +177,7 @@ - (void)setSd_imageProgress:(NSProgress *)sd_imageProgress {
 #if SD_UIKIT || SD_MAC
             // check and stop image indicator
             if (finished) {
-                [self sd_stopImageIndicator];
+                [self sd_stopImageIndicatorWithQueue:queue];
             }
 #endif
 
@@ -197,7 +198,7 @@ - (void)setSd_imageProgress:(NSProgress *)sd_imageProgress {
             // OR
             // case 1b: we got no image and the SDWebImageDelayPlaceholder is not set
             if (shouldNotSetImage) {
-                dispatch_main_async_safe(callCompletedBlockClosure);
+                [(queue ?: SDCallbackQueue.mainQueue) async:callCompletedBlockClosure];
                 return;
             }
 
@@ -242,25 +243,25 @@ - (void)setSd_imageProgress:(NSProgress *)sd_imageProgress {
                 transition = self.sd_imageTransition;
             }
 #endif
-            dispatch_main_async_safe(^{
+            [(queue ?: SDCallbackQueue.mainQueue) async:^{
 #if SD_UIKIT || SD_MAC
                 [self sd_setImage:targetImage imageData:targetData options:options basedOnClassOrViaCustomSetImageBlock:setImageBlock transition:transition cacheType:cacheType imageURL:imageURL callback:callCompletedBlockClosure];
 #else
                 [self sd_setImage:targetImage imageData:targetData basedOnClassOrViaCustomSetImageBlock:setImageBlock cacheType:cacheType imageURL:imageURL];
                 callCompletedBlockClosure();
 #endif
-            });
+            }];
         }];
         [self sd_setImageLoadOperation:operation forKey:validOperationKey];
     } else {
 #if SD_UIKIT || SD_MAC
-        [self sd_stopImageIndicator];
+        [self sd_stopImageIndicatorWithQueue:queue];
 #endif
         if (completedBlock) {
-            dispatch_main_async_safe(^{
+            [(queue ?: SDCallbackQueue.mainQueue) async:^{
                 NSError *error = [NSError errorWithDomain:SDWebImageErrorDomain code:SDWebImageErrorInvalidURL userInfo:@{NSLocalizedDescriptionKey : @"Image url is nil"}];
                 completedBlock(nil, nil, error, SDImageCacheTypeNone, YES, url);
-            });
+            }];
         }
     }
 
@@ -482,24 +483,24 @@ - (void)setSd_imageIndicator:(id<SDWebImageIndicator>)sd_imageIndicator {
     [self addSubview:view];
 }
 
-- (void)sd_startImageIndicator {
+- (void)sd_startImageIndicatorWithQueue:(SDCallbackQueue *)queue {
     id<SDWebImageIndicator> imageIndicator = self.sd_imageIndicator;
     if (!imageIndicator) {
         return;
     }
-    dispatch_main_async_safe(^{
+    [(queue ?: SDCallbackQueue.mainQueue) async:^{
         [imageIndicator startAnimatingIndicator];
-    });
+    }];
 }
 
-- (void)sd_stopImageIndicator {
+- (void)sd_stopImageIndicatorWithQueue:(SDCallbackQueue *)queue {
     id<SDWebImageIndicator> imageIndicator = self.sd_imageIndicator;
     if (!imageIndicator) {
         return;
     }
-    dispatch_main_async_safe(^{
+    [(queue ?: SDCallbackQueue.mainQueue) async:^{
         [imageIndicator stopAnimatingIndicator];
-    });
+    }];
 }
 
 #endif