[关闭]
@qidiandasheng 2022-08-07T21:42:01.000000Z 字数 19273 阅读 595

多线程使用案例（❎）

iOS实战

数据持久化

如果在主线程中存储数据，数据量比较大时会阻塞主线程造成页面卡顿。需要新开线程在后台处理。

然而新开的线程过多也会引起过多的内存和线程上下文切换的性能损耗问题，所以类似数据库这种需要频繁读写磁盘操作的任务，尽量使用串行队列来管理，避免因为多线程并发而出现内存问题。

在进行数据读写操作时，总是需要一段时间来等待磁盘响应的，如果在这个时候通过 GCD 发起了一个任务，那么 GCD 就会本着最大化利用 CPU 的原则，会在等待磁盘响应的这个空档，再创建一个新线程来保证能够充分利用 CPU。

而如果 GCD 发起的这些新任务，都是类似于数据存储这样需要等待磁盘响应的任务的话，那么随着任务数量的增加，GCD 创建的新线程就会越来越多，从而导致内存资源越来越紧张，等到磁盘开始响应后，再读取数据又会占用更多的内存。结果就是，失控的内存占用会引起更多的内存问题。

IM数据库写入

Hermes项目里使用异步串行队列来进行数据库的写入。

  1. //创建串行队列
  2. static let writeQueue = DispatchQueue(label: "chat.rocket.realm.write", qos: .background)
  4. public func execute(_ execution: @escaping (Realm) -> Void, completion: VoidCompletion? = nil) {
  5.     var backgroundTaskId: UIBackgroundTaskIdentifier?
  7.     //创建后台任务，当app退入后台时也能继续执行一小段时间
  8.     backgroundTaskId = UIApplication.shared.beginBackgroundTask(withName: "chat.rocket.realm.background") {
  9.         backgroundTaskId = UIBackgroundTaskInvalid
  10.     }
  13.     if let backgroundTaskId = backgroundTaskId {
  14.         let config = self.configuration
  16.         //在异步串行队列里执行数据库写入任务
  17.         Realm.writeQueue.async {
  18.             if let realm = try? Realm(configuration: config) {
  19.                 try? realm.write {
  20.                     execution(realm)
  21.                 }
  22.             }
  24.             if let completion = completion {
  25.                 DispatchQueue.main.async {
  26.                     completion()
  27.                 }
  28.             }
  30.             UIApplication.shared.endBackgroundTask(backgroundTaskId)
  31.         }
  32.     }
  33. }

SDImageCache

SDImageCache是SDWebImage的缓存处理模块。SDImageCache分为内存缓存和磁盘缓存。

内存缓存通过一个信号量锁来处理多线程安全问题：

  1. - (void)setObject:(id)obj forKey:(id)key cost:(NSUInteger)g {
  2.     [super setObject:obj forKey:key cost:g];
  3.     if (!self.config.shouldUseWeakMemoryCache) {
  4.         return;
  5.     }
  6.     if (key && obj) {
  7.         // Store weak cache
  8.         LOCK(self.weakCacheLock);
  9.         [self.weakCache setObject:obj forKey:key];
  10.         UNLOCK(self.weakCacheLock);
  11.     }
  12. }
  14. - (id)objectForKey:(id)key {
  15.     id obj = [super objectForKey:key];
  16.     if (!self.config.shouldUseWeakMemoryCache) {
  17.         return obj;
  18.     }
  19.     if (key && !obj) {
  20.         // Check weak cache
  21.         LOCK(self.weakCacheLock);
  22.         obj = [self.weakCache objectForKey:key];
  23.         UNLOCK(self.weakCacheLock);
  24.         if (obj) {
  25.             // Sync cache
  26.             NSUInteger cost = 0;
  27.             if ([obj isKindOfClass:[UIImage class]]) {
  28.                 cost = SDCacheCostForImage(obj);
  29.             }
  30.             [super setObject:obj forKey:key cost:cost];
  31.         }
  32.     }
  33.     return obj;
  34. }
  36. - (void)removeObjectForKey:(id)key {
  37.     [super removeObjectForKey:key];
  38.     if (!self.config.shouldUseWeakMemoryCache) {
  39.         return;
  40.     }
  41.     if (key) {
  42.         // Remove weak cache
  43.         LOCK(self.weakCacheLock);
  44.         [self.weakCache removeObjectForKey:key];
  45.         UNLOCK(self.weakCacheLock);
  46.     }
  47. }

磁盘缓存通过一个异步串行队列来读写数据：

  1. //创建串行队列
  2. _ioQueue = dispatch_queue_create("com.hackemist.SDWebImageCache", DISPATCH_QUEUE_SERIAL);
  1. //写入本地磁盘
  2. - (void)storeImage:(nullable UIImage *)image
  3.          imageData:(nullable NSData *)imageData
  4.             forKey:(nullable NSString *)key
  5.             toDisk:(BOOL)toDisk
  6.         completion:(nullable SDWebImageNoParamsBlock)completionBlock {
  7.     if (!image || !key) {
  8.         if (completionBlock) {
  9.             completionBlock();
  10.         }
  11.         return;
  12.     }
  13.     // if memory cache is enabled
  14.     if (self.config.shouldCacheImagesInMemory) {
  15.         NSUInteger cost = SDCacheCostForImage(image);
  16.         [self.memCache setObject:image forKey:key cost:cost];
  17.     }
  19.     if (toDisk) {
  20.         dispatch_async(self.ioQueue, ^{
  21.             @autoreleasepool {
  22.                 NSData *data = imageData;
  23.                 if (!data && image) {
  24.                     // If we do not have any data to detect image format, check whether it contains alpha channel to use PNG or JPEG format
  25.                     SDImageFormat format;
  26.                     if (SDCGImageRefContainsAlpha(image.CGImage)) {
  27.                         format = SDImageFormatPNG;
  28.                     } else {
  29.                         format = SDImageFormatJPEG;
  30.                     }
  31.                     data = [[SDWebImageCodersManager sharedInstance] encodedDataWithImage:image format:format];
  32.                 }
  33.                 [self _storeImageDataToDisk:data forKey:key];
  34.             }
  36.             if (completionBlock) {
  37.                 dispatch_async(dispatch_get_main_queue(), ^{
  38.                     completionBlock();
  39.                 });
  40.             }
  41.         });
  42.     } else {
  43.         if (completionBlock) {
  44.             completionBlock();
  45.         }
  46.     }
  47. }
  1. //从本地磁盘读取
  2. - (void)diskImageExistsWithKey:(nullable NSString *)key completion:(nullable SDWebImageCheckCacheCompletionBlock)completionBlock {
  3.     dispatch_async(self.ioQueue, ^{
  4.         BOOL exists = [self _diskImageDataExistsWithKey:key];
  5.         if (completionBlock) {
  6.             dispatch_async(dispatch_get_main_queue(), ^{
  7.                 completionBlock(exists);
  8.             });
  9.         }
  10.     });
  11. }

耗时代码处理

如果使用多次数的循环语句，或者是使用非常耗时的api时，会影响到主线程导致卡顿。可以新开线程在后台处理，然后如果有需要刷新UI则在主线程中同步。

长链接消息接收回调

Hermes项目里websocket长链接会接到很多消息的回调，这些回调可能会拖慢主线程的时间，所以放入一个异步线程串行的执行消息回调。

  1. //创建一个串行队列，优先级为background
  2. static let messageHandlerQueue = DispatchQueue(label: "chat.rocket.websocket.handler", qos: .background)
  4. public func websocketDidReceiveMessage(socket: WebSocket, text: String) {
  5.     let json = JSON(parseJSON: text)
  7.     // JSON is invalid
  8.     guard json.exists() else {
  9.         Log.debug("[WebSocket] \(socket.currentURL)\n - did receive invalid JSON object:\n\(text)")
  10.         return
  11.     }
  13.     if let raw = json.rawString() {
  14.         Log.debug("[WebSocket] \(socket.currentURL)\n - did receive JSON message:\n\(raw)")
  15.     }
  17.     //收到websocket的消息时异步的串行执行回调任务
  18.     SocketManager.messageHandlerQueue.async {
  19.         self.handleMessage(json, socket: socket)
  20.     }
  21. }

异步绘制

  1. static dispatch_queue_t YYAsyncLayerGetDisplayQueue() {
  2. //最大队列数量
  3. #define MAX_QUEUE_COUNT 16
  4. //队列数量
  5.     static int queueCount;
  6. //使用栈区的数组存储队列
  7.     static dispatch_queue_t queues[MAX_QUEUE_COUNT];
  8.     static dispatch_once_t onceToken;
  9.     static int32_t counter = 0;
  10.     dispatch_once(&onceToken, ^{
  11. //要点 1 ：串行队列数量和处理器数量相同
  12.         queueCount = (int)[NSProcessInfo processInfo].activeProcessorCount;
  13.         queueCount = queueCount < 1 ? 1 : queueCount > MAX_QUEUE_COUNT ? MAX_QUEUE_COUNT : queueCount;
  14. //要点 2 ：创建串行队列，设置优先级
  15.         if ([UIDevice currentDevice].systemVersion.floatValue >= 8.0) {
  16.             for (NSUInteger i = 0; i < queueCount; i++) {
  17.                 dispatch_queue_attr_t attr = dispatch_queue_attr_make_with_qos_class(DISPATCH_QUEUE_SERIAL, QOS_CLASS_USER_INITIATED, 0);
  18.                 queues[i] = dispatch_queue_create("com.ibireme.yykit.render", attr);
  19.             }
  20.         } else {
  21.             for (NSUInteger i = 0; i < queueCount; i++) {
  22.                 queues[i] = dispatch_queue_create("com.ibireme.yykit.render", DISPATCH_QUEUE_SERIAL);
  23.                 dispatch_set_target_queue(queues[i], dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0));
  24.             }
  25.         }
  26.     });
  27. //要点 3 ：轮询返回队列
  28.     int32_t cur = OSAtomicIncrement32(&counter);
  29.     if (cur < 0) cur = -cur;
  30.     return queues[(cur) % queueCount];
  31. #undef MAX_QUEUE_COUNT
  32. }
  35. dispatch_async(YYAsyncLayerGetDisplayQueue(), ^{
  36.     //绘制
  37.     UIGraphicsBeginImageContextWithOptions(size, opaque, scale);
  38.     .....
  39.     UIGraphicsEndImageContext();
  41.     //回到主线程显示
  42.     dispatch_async(dispatch_get_main_queue(), ^{
  43.         if (isCancelled()) {
  44.             if (task.didDisplay) task.didDisplay(self, NO);
  45.         } else {
  46.             self.contents = (__bridge id)(image.CGImage);
  47.             if (task.didDisplay) task.didDisplay(self, YES);
  48.         }
  49.     });
  50. }

或者我认为可以使用NSOperationQueue：

  1. #define MAX_QUEUE_COUNT 16
  2. static int queueCount;
  3. queueCount = (int)[NSProcessInfo processInfo].activeProcessorCount;
  4. queueCount = queueCount < 1 ? 1 : queueCount > MAX_QUEUE_COUNT ? MAX_QUEUE_COUNT : queueCount;
  6. NSOperationQueue *queue = [[NSOperationQueue alloc] init];
  7. queue.maxConcurrentOperationCount = queueCount;
  9. NSBlockOperation *p = [NSBlockOperation blockOperationWithBlock:^{
  10.     //绘制
  11.     UIGraphicsBeginImageContextWithOptions(size, opaque, scale);
  12.     .....
  13.     UIGraphicsEndImageContext();
  15.     //回到主线程显示
  16.     dispatch_async(dispatch_get_main_queue(), ^{
  17.         if (isCancelled()) {
  18.             if (task.didDisplay) task.didDisplay(self, NO);
  19.         } else {
  20.             self.contents = (__bridge id)(image.CGImage);
  21.             if (task.didDisplay) task.didDisplay(self, YES);
  22.         }
  23.     });
  24. }];
  26. [queue addOperation:p];

网络请求等待

主线程异步调用请求问题？

原因一：

如果我们放到主线程去做，势必要这么写：

  1. [[NSURLConnection alloc] initWithRequest:request delegate:self startImmediately:YES]

这样NSURLConnection的回调会被放在主线程中NSDefaultRunLoopMode中，这样我们在其它类似UITrackingRunLoopMode模式下，我们是得不到网络请求的结果的，这显然不是我们想要的，那么我们势必需要调用：

  1. [connection scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSRunLoopCommonModes];

把它加入NSRunLoopCommonModes中，试想如果有大量的网络请求，同时回调回来，就会影响我们的UI体验了。

原因二：

如果我们请求数据返回，势必要进行数据解析，解析成我们需要的格式，那么这些解析都在主线程中做，给主线程增加额外的负担。

又或者我们回调回来开辟一个新的线程去做数据解析，那么我们有n个请求回来开辟n条线程带来的性能损耗，以及线程间切换带来的损耗，是不是一笔更大的开销。

开辟n条线程做请求问题？

如果开发n条线程做请求的话，那就需要设置runloop保活住线程，等待结果回调。为了等待不确定的请求结果，阻塞住线程，白白浪费n条线程的开销。

AFNetworking3.0初始化

  1. - (instancetype)initWithSessionConfiguration:(NSURLSessionConfiguration *)configuration {
  2.     self = [super init];
  3.     if (!self) {
  4.         return nil;
  5.     }
  7.     .....
  9.     self.operationQueue = [[NSOperationQueue alloc] init];
  10.     self.operationQueue.maxConcurrentOperationCount = 1;
  12.     .....
  13. }
  15. - (NSURLSession *)session {
  17.     @synchronized (self) {
  18.         if (!_session) {
  19.             _session = [NSURLSession sessionWithConfiguration:self.sessionConfiguration delegate:self delegateQueue:self.operationQueue];
  20.         }
  21.     }
  22.     return _session;
  23. }

这个operationQueue就是我们代理回调的queue。这里把代理回调的线程并发数设置为1了。

这里的并发数仅仅是回调代理的线程并发数。而不是请求网络的线程并发数。请求网络是由NSUrlSession来做的，它内部维护了一个线程池，用来做网络请求。它调度线程,基于底层的CFSocket去发送请求和接收数据。这些线程是并发的。

AFNetworking3.0回调

  1. static dispatch_queue_t url_session_manager_processing_queue() {
  2.     static dispatch_queue_t af_url_session_manager_processing_queue;
  3.     static dispatch_once_t onceToken;
  4.     dispatch_once(&onceToken, ^{
  5.         af_url_session_manager_processing_queue = dispatch_queue_create("com.alamofire.networking.session.manager.processing", DISPATCH_QUEUE_CONCURRENT);
  6.     });
  8.     return af_url_session_manager_processing_queue;
  9. }
  1. - (void)URLSession:(__unused NSURLSession *)session
  2.               task:(NSURLSessionTask *)task
  3. didCompleteWithError:(NSError *)error
  4. {
  6.     if (error) {
  7.         userInfo[AFNetworkingTaskDidCompleteErrorKey] = error;
  9.         dispatch_group_async(manager.completionGroup ?: url_session_manager_completion_group(), manager.completionQueue ?: dispatch_get_main_queue(), ^{
  10.             if (self.completionHandler) {
  11.                 self.completionHandler(task.response, responseObject, error);
  12.             }
  14.             dispatch_async(dispatch_get_main_queue(), ^{
  15.                 [[NSNotificationCenter defaultCenter] postNotificationName:AFNetworkingTaskDidCompleteNotification object:task userInfo:userInfo];
  16.             });
  17.         });
  18.     } else {
  19.         dispatch_async(url_session_manager_processing_queue(), ^{
  21.             #并发队列数据解析
  22.             ......
  24.             dispatch_group_async(manager.completionGroup ?: url_session_manager_completion_group(), manager.completionQueue ?: dispatch_get_main_queue(), ^{
  25.                 if (self.completionHandler) {
  26.                     self.completionHandler(task.response, responseObject, serializationError);
  27.                 }
  29.                 dispatch_async(dispatch_get_main_queue(), ^{
  30.                     [[NSNotificationCenter defaultCenter] postNotificationName:AFNetworkingTaskDidCompleteNotification object:task userInfo:userInfo];
  31.                 });
  32.             });
  33.         });
  34.     }
  35. }

按照初始化设置，这里的回调是串行回调回来的，只会开辟一条线程，没必要为不确定的网络请求回调开辟多条线程，如果网络一直在等待的话那就会浪费线程资源。

当数据串行回调回来之后，就使用并发队列创建多条线程来进行数据的解析了，最后放到一个GCD group里面，使用者可以自己设置group，那就可以监听所有的回调完成。

AF3.x的整个流程和线程的关系

加载网络资源

SDWebImage的异步下载

SDWebImageDownloader为图片下载器对象，里面主要管理着SDWebImageDownloaderOperation进行对图片的下载。

SDWebImageDownloaderOperation

每一个图片下载都是一个SDWebImageDownloaderOperation操作，SDWebImageDownloaderOperation继承自NSOperation，内部创建NSURLSessionTask来进行图片下载的请求（NSURLSession由SDWebImageDownloader传入）。

  1. - (nonnull instancetype)initWithRequest:(nullable NSURLRequest *)request
  2.                               inSession:(nullable NSURLSession *)session
  3.                                 options:(SDWebImageDownloaderOptions)options {
  4.     if ((self = [super init])) {
  5.         _request = [request copy];
  6.         _shouldDecompressImages = YES;
  7.         _options = options;
  8.         _callbackBlocks = [NSMutableArray new];
  9.         _executing = NO;
  10.         _finished = NO;
  11.         _expectedSize = 0;
  12.         _unownedSession = session;
  13.         _callbacksLock = dispatch_semaphore_create(1);
  14.         _coderQueue = dispatch_queue_create("com.hackemist.SDWebImageDownloaderOperationCoderQueue", DISPATCH_QUEUE_SERIAL);
  15.     }
  16.     return self;
  17. }
  20. - (void)start {
  21.     @synchronized (self) {
  22.         if (self.isCancelled) {
  23.             self.finished = YES;
  24.             [self reset];
  25.             return;
  26.         }
  28. #if SD_UIKIT
  29.         Class UIApplicationClass = NSClassFromString(@"UIApplication");
  30.         BOOL hasApplication = UIApplicationClass && [UIApplicationClass respondsToSelector:@selector(sharedApplication)];
  31.         if (hasApplication && [self shouldContinueWhenAppEntersBackground]) {
  32.             __weak __typeof__ (self) wself = self;
  33.             UIApplication * app = [UIApplicationClass performSelector:@selector(sharedApplication)];
  34.             self.backgroundTaskId = [app beginBackgroundTaskWithExpirationHandler:^{
  35.                 __strong __typeof (wself) sself = wself;
  37.                 if (sself) {
  38.                     [sself cancel];
  40.                     [app endBackgroundTask:sself.backgroundTaskId];
  41.                     sself.backgroundTaskId = UIBackgroundTaskInvalid;
  42.                 }
  43.             }];
  44.         }
  45. #endif
  46.         NSURLSession *session = self.unownedSession;
  47.         if (!session) {
  48.             NSURLSessionConfiguration *sessionConfig = [NSURLSessionConfiguration defaultSessionConfiguration];
  49.             sessionConfig.timeoutIntervalForRequest = 15;
  51.             /**
  52.              *  Create the session for this task
  53.              *  We send nil as delegate queue so that the session creates a serial operation queue for performing all delegate
  54.              *  method calls and completion handler calls.
  55.              */
  56.             session = [NSURLSession sessionWithConfiguration:sessionConfig
  57.                                                     delegate:self
  58.                                                delegateQueue:nil];
  59.             self.ownedSession = session;
  60.         }
  62.         if (self.options & SDWebImageDownloaderIgnoreCachedResponse) {
  63.             // Grab the cached data for later check
  64.             NSURLCache *URLCache = session.configuration.URLCache;
  65.             if (!URLCache) {
  66.                 URLCache = [NSURLCache sharedURLCache];
  67.             }
  68.             NSCachedURLResponse *cachedResponse;
  69.             // NSURLCache's `cachedResponseForRequest:` is not thread-safe, see https://developer.apple.com/documentation/foundation/nsurlcache#2317483
  70.             @synchronized (URLCache) {
  71.                 cachedResponse = [URLCache cachedResponseForRequest:self.request];
  72.             }
  73.             if (cachedResponse) {
  74.                 self.cachedData = cachedResponse.data;
  75.             }
  76.         }
  78.         self.dataTask = [session dataTaskWithRequest:self.request];
  79.         self.executing = YES;
  80.     }
  82.     if (self.dataTask) {
  83. #pragma clang diagnostic push
  84. #pragma clang diagnostic ignored "-Wunguarded-availability"
  85.         if ([self.dataTask respondsToSelector:@selector(setPriority:)]) {
  86.             if (self.options & SDWebImageDownloaderHighPriority) {
  87.                 self.dataTask.priority = NSURLSessionTaskPriorityHigh;
  88.             } else if (self.options & SDWebImageDownloaderLowPriority) {
  89.                 self.dataTask.priority = NSURLSessionTaskPriorityLow;
  90.             }
  91.         }
  92. #pragma clang diagnostic pop
  93.         [self.dataTask resume];
  94.         for (SDWebImageDownloaderProgressBlock progressBlock in [self callbacksForKey:kProgressCallbackKey]) {
  95.             progressBlock(0, NSURLResponseUnknownLength, self.request.URL);
  96.         }
  97.         __weak typeof(self) weakSelf = self;
  98.         dispatch_async(dispatch_get_main_queue(), ^{
  99.             [[NSNotificationCenter defaultCenter] postNotificationName:SDWebImageDownloadStartNotification object:weakSelf];
  100.         });
  101.     } else {
  102.         [self callCompletionBlocksWithError:[NSError errorWithDomain:NSURLErrorDomain code:NSURLErrorUnknown userInfo:@{NSLocalizedDescriptionKey : @"Task can't be initialized"}]];
  103.         [self done];
  104.         return;
  105.     }
  107. #if SD_UIKIT
  108.     Class UIApplicationClass = NSClassFromString(@"UIApplication");
  109.     if(!UIApplicationClass || ![UIApplicationClass respondsToSelector:@selector(sharedApplication)]) {
  110.         return;
  111.     }
  112.     if (self.backgroundTaskId != UIBackgroundTaskInvalid) {
  113.         UIApplication * app = [UIApplication performSelector:@selector(sharedApplication)];
  114.         [app endBackgroundTask:self.backgroundTaskId];
  115.         self.backgroundTaskId = UIBackgroundTaskInvalid;
  116.     }
  117. #endif
  118. }

SDWebImageDownloader

SDWebImageDownloader维护着一个下载队列downloadQueue，默认最大并发数为6，也可以自定义。

  1. - (nonnull instancetype)initWithSessionConfiguration:(nullable NSURLSessionConfiguration *)sessionConfiguration {
  2.     if ((self = [super init])) {
  3.         _operationClass = [SDWebImageDownloaderOperation class];
  4.         _shouldDecompressImages = YES;
  5.         _executionOrder = SDWebImageDownloaderFIFOExecutionOrder;
  6.         _downloadQueue = [NSOperationQueue new];
  7.         _downloadQueue.maxConcurrentOperationCount = 6;
  8.         _downloadQueue.name = @"com.hackemist.SDWebImageDownloader";
  9.         _URLOperations = [NSMutableDictionary new];
  10.         SDHTTPHeadersMutableDictionary *headerDictionary = [SDHTTPHeadersMutableDictionary dictionary];
  11.         NSString *userAgent = nil;
  13.         .......
  15.         _HTTPHeaders = headerDictionary;
  16.         _operationsLock = dispatch_semaphore_create(1);
  17.         _headersLock = dispatch_semaphore_create(1);
  18.         _downloadTimeout = 15.0;
  20.         //创建NSURLSession
  21.         [self createNewSessionWithConfiguration:sessionConfiguration];
  22.     }
  23.     return self;
  24. }
  1. //创建对应的operation放入下载队列中（初始化创建的NSURLSession传入每一个operation中）
  2. - (nullable SDWebImageDownloadToken *)downloadImageWithURL:(nullable NSURL *)url
  3.                                                    options:(SDWebImageDownloaderOptions)options
  4.                                                   progress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
  5.                                                  completed:(nullable SDWebImageDownloaderCompletedBlock)completedBlock {
  6.     // The URL will be used as the key to the callbacks dictionary so it cannot be nil. If it is nil immediately call the completed block with no image or data.
  7.     if (url == nil) {
  8.         if (completedBlock != nil) {
  9.             completedBlock(nil, nil, nil, NO);
  10.         }
  11.         return nil;
  12.     }
  14.     LOCK(self.operationsLock);
  15.     NSOperation<SDWebImageDownloaderOperationInterface> *operation = [self.URLOperations objectForKey:url];
  16.     // There is a case that the operation may be marked as finished, but not been removed from `self.URLOperations`.
  17.     if (!operation || operation.isFinished) {
  18.         operation = [self createDownloaderOperationWithUrl:url options:options];
  19.         __weak typeof(self) wself = self;
  20.         operation.completionBlock = ^{
  21.             __strong typeof(wself) sself = wself;
  22.             if (!sself) {
  23.                 return;
  24.             }
  25.             LOCK(sself.operationsLock);
  26.             [sself.URLOperations removeObjectForKey:url];
  27.             UNLOCK(sself.operationsLock);
  28.         };
  29.         [self.URLOperations setObject:operation forKey:url];
  30.         // Add operation to operation queue only after all configuration done according to Apple's doc.
  31.         // `addOperation:` does not synchronously execute the `operation.completionBlock` so this will not cause deadlock.
  32.         [self.downloadQueue addOperation:operation];
  33.     }
  34.     UNLOCK(self.operationsLock);
  36.     id downloadOperationCancelToken = [operation addHandlersForProgress:progressBlock completed:completedBlock];
  38.     SDWebImageDownloadToken *token = [SDWebImageDownloadToken new];
  39.     token.downloadOperation = operation;
  40.     token.url = url;
  41.     token.downloadOperationCancelToken = downloadOperationCancelToken;
  43.     return token;
  44. }

在SDWebImageDownloader中实现NSURLSessionDataDelegate和NSURLSessionTaskDelegate委托方法，然后根据回调的taskid找到对应的operation，执行对应的operation里的回调方法:

  1. #pragma mark NSURLSessionDataDelegate
  3. .......
  5. #pragma mark NSURLSessionTaskDelegate
  7. - (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error {
  9.     // Identify the operation that runs this task and pass it the delegate method
  10.     NSOperation<SDWebImageDownloaderOperationInterface> *dataOperation = [self operationWithTask:task];
  11.     if ([dataOperation respondsToSelector:@selector(URLSession:task:didCompleteWithError:)]) {
  12.         [dataOperation URLSession:session task:task didCompleteWithError:error];
  13.     }
  14. }

任务组和栅栏

可使用任务组和栅栏处理多个异步操作完成之后再执行后面的操作的情况。比如获取两个异步请求数据后才渲染界面的情况。

  1. dispatch_group_t group = dispatch_group_create();
  3. dispatch_group_enter(group);
  4. NSURLSessionDataTask *task = [[NSURLSession sharedSession] dataTaskWithRequest:[NSURLRequest requestWithURL:[NSURL URLWithString:@"http://www.baidu.com"]] completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
  6.     NSLog(@"A");
  7.     dispatch_group_leave(group);
  8. }] ;
  9. [task resume];
  11. dispatch_group_enter(group);
  12. NSURLSessionDataTask *task2 = [[NSURLSession sharedSession] dataTaskWithRequest:[NSURLRequest requestWithURL:[NSURL URLWithString:@"http://www.baidu.com"]] completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
  14.     NSLog(@"B");
  15.     dispatch_group_leave(group);
  16. }] ;
  17. [task2 resume];
  19. dispatch_group_notify(group, dispatch_get_main_queue(), ^{
  20.     NSLog(@"all end");
  21. });
  1. dispatch_queue_t queue =  dispatch_queue_create(0, DISPATCH_QUEUE_CONCURRENT);
  3. dispatch_async(queue, ^{
  4.     __block BOOL isExecuted = NO;
  5.     NSURLSessionDataTask *task = [[NSURLSession sharedSession] dataTaskWithRequest:[NSURLRequest requestWithURL:[NSURL URLWithString:@"http://www.baidu.com"]] completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
  7.         NSLog(@"A");
  8.         isExecuted = YES;
  9.     }] ;
  10.     [task resume];
  11.     while (isExecuted == NO) {
  12.         [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];
  13.     }
  14. });
  16. dispatch_async(queue, ^{
  17.     __block BOOL isExecuted = NO;
  18.     NSURLSessionDataTask *task = [[NSURLSession sharedSession] dataTaskWithRequest:[NSURLRequest requestWithURL:[NSURL URLWithString:@"http://www.baidu.com"]] completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
  20.         NSLog(@"B");
  21.         isExecuted = YES;
  22.     }] ;
  23.     [task resume];
  24.     while (isExecuted == NO) {
  25.         [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];
  26.     }
  27. });
  30. //让barrier之前的线程执行完成之后才会执行barrier后面的操作
  31. dispatch_barrier_async(queue, ^{
  32.     __block BOOL isExecuted = NO;
  33.     NSURLSessionDataTask *task = [[NSURLSession sharedSession] dataTaskWithRequest:[NSURLRequest requestWithURL:[NSURL URLWithString:@"http://www.baidu.com"]] completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
  35.         NSLog(@"拿到了A的值");
  36.         isExecuted = YES;
  37.     }] ;
  38.     [task resume];
  39.     while (isExecuted == NO) {
  40.         [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];
  41.     }
  42. });
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注