SDWebImage这个第三方库有多厉害，从它的GitHub上过万的Star就可以看出来。一直以来都想好好拜读它的源码，但之前每次都看得头昏脑胀的，最后都是不了了之。方知武侠小说中修为没到，强练绝世秘籍会导致走火入魔的说法并不是无稽之谈。

害怕.jpg

最近项目没有这么紧张，又静下心来，好好研读了几遍。终于看出了一点点门道，所以写篇笔记记录一下。话不多说，进入正题。先来一张流程图压压惊：

流程图.png

本文采用讲解主体逻辑，贴出源码，并在源码中添加注释的方法；同时会把比较有特色的点，结合自己的理解，稍作分析。作为iOS码农界的小学生，能力有限，水平一般（脑补郭德纲的声音。。。）。如有不对之处，还望指正。

为已有的类添加方法，毫无疑问应该首先想到类别（Category）这种方法。那直接进入到UIImageView+WebCache.m文件中，看到一系列的方法，其实最终都是走到了UIView+WebCache.m的的这个方法中：

- (void)sd_internalSetImageWithURL:(nullable NSURL *)url
                  placeholderImage:(nullable UIImage *)placeholder
                           options:(SDWebImageOptions)options
                      operationKey:(nullable NSString *)operationKey
                     setImageBlock:(nullable SDSetImageBlock)setImageBlock
                          progress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
                         completed:(nullable SDExternalCompletionBlock)completedBlock
                           context:(nullable NSDictionary<NSString *, id> *)context;

为什么要这么设计呢？因为前面流程图上说了，不光UIImageView有扩展，UIButton也有扩展方法，那么把最终的实现放到他们的共同父类UIView的类别中，也就顺理成章了。方法实现中，一进来是这么两行代码：

NSString *validOperationKey = operationKey ?: NSStringFromClass([self class]);
[self sd_cancelImageLoadOperationWithKey:validOperationKey];

这个validOperationKey其实就是为了缓存或者从缓存中查找operation当作key用的；如果外部没有传入的话，就默认的取类名。先用这个key取消可能正在操作的operation，避免后续的回调混乱，保证这个Imageview或者Button只存在一个请求图片的操作。进入sd_cancelImageLoadOperationWithKey：方法的内部，可以看到是在UIView+WebCacheOperation.m中实现的。这里将key和operation映射保存在动态绑定的SDOperationsDictionary中，名字是dictionary，实际上用到的是NSMapTable。类似于字典，但比字典更灵活的一个类。这篇文章说的比较详细。
接下来是动态绑定url到当前对象上；如果设置的options不是延迟设置占位图的话，就在主线程回调设置占位图：

//动态绑定url到当前对象上
objc_setAssociatedObject(self, &imageURLKey, url, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
//如果设置的options不是延迟设置占位图的话，就在主线程回调设置占位图
if (!(options & SDWebImageDelayPlaceholder)) {
        dispatch_main_async_safe(^{
            [self sd_setImage:placeholder imageData:nil basedOnClassOrViaCustomSetImageBlock:setImageBlock];
        });
    }

接下来的这个最外层的if else的大逻辑就是，如果传入的url不为nil的话，就走下面一大段逻辑；否则发起错误回调。看看url不为空后续的逻辑，对照着注释应该比较清楚：

#if SD_UIKIT
        // 检查activityView是否可用
        if ([self sd_showActivityIndicatorView]) {
            //添加菊花控件
            [self sd_addActivityIndicator];
        }
#endif
        
        // 初始化sd_imageProgress的总任务数和任务完成数
        self.sd_imageProgress.totalUnitCount = 0;
        self.sd_imageProgress.completedUnitCount = 0;
        
        //取到manager，如果外部传入了就用传入的值
        SDWebImageManager *manager;
        if ([context valueForKey:SDWebImageExternalCustomManagerKey]) {
            manager = (SDWebImageManager *)[context valueForKey:SDWebImageExternalCustomManagerKey];
        } else {
            manager = [SDWebImageManager sharedManager];
        }
        
        //弱引用self，防止引用循环
        __weak __typeof(self)wself = self;
        //把传进来的progressBlock封装一下，后续生成operation时使用
        SDWebImageDownloaderProgressBlock combinedProgressBlock = ^(NSInteger receivedSize, NSInteger expectedSize, NSURL * _Nullable targetURL) {
            wself.sd_imageProgress.totalUnitCount = expectedSize;
            wself.sd_imageProgress.completedUnitCount = receivedSize;
            if (progressBlock) {
                progressBlock(receivedSize, expectedSize, targetURL);
            }
        };

其中的SD_UIKIT宏定义后面会频繁出现，其实就类似一个bool值，在iOS和tvOS中为真，其他系统下为假：

#if TARGET_OS_IOS || TARGET_OS_TV
    #define SD_UIKIT 1
#else
    #define SD_UIKIT 0
#endif

然后是生成operation的实现：

id <SDWebImageOperation> operation = [manager loadImageWithURL:url options:options progress:combinedProgressBlock completed:^(UIImage *image, NSData *data, NSError *error, SDImageCacheType cacheType, BOOL finished, NSURL *imageURL) {
            __strong __typeof (wself) sself = wself;
            if (!sself) { return; }
#if SD_UIKIT
            [sself sd_removeActivityIndicator];
#endif
...

代码太长了没有截完，大体逻辑就是manager使用传进来的url，options，completedBlock，和上面生成的combinedProgressBlock参数，生成一个operation，并把它和key映射保存在动态绑定的SDOperationsDictionary中。我们不管生成operation的细节，先来看看它的回调block实现。

block一进来是对weakSelf的强引用，因为前面对self进行了弱引用。这里说个比较有意思的点。以前最开始看到block实现中这种先weak再strong的做法我其实非常不理解，疑惑的是这样做到底会不会增加该对象的引用计数？如果会的话这跟不做转换有什么区别？当时百度google了一大堆，硬是没有看懂，所以这个问题拖了很久，面试还被问到过。后来有一次突然看到一篇文章里面说，block里面的strong引用weakSelf，是为了防止多线程切换的时候，weakSelf被提前释放了，后续再访问该对象的时候，引起野指针崩溃才这么做的。我突然豁然开朗，原来先weak后strong的目的其实有两个：

• 先weak引用当前对象，是为了让block捕获的对象是一个弱引用的对象。这样就打破了引用循环，防止双方都强引用对方，形成引用循环，导致内存泄漏。
• block内部的strong是为了增加对象的引用计数，保证该对象在block内部是一直存在的，防止在多线程切换的时候对象被提前释放，后续访问导致野指针崩溃。

有时候不得不感叹，能够在特定的时间节点碰到对的人或物，是多么幸运的一件事情。

好了，我们继续来看回调block的实现细节,主要是一些条件判断和回调处理，没有什么值得特别说明的，对照注释应该是挺好理解的：

#if SD_UIKIT
            //如果前面添加了菊花控件，这里先移除
            [sself sd_removeActivityIndicator];
#endif
            // 如果操作完成，没有错误，而且progress没有更新的话，手动将其置为Unknown状态。
            if (finished && !error && sself.sd_imageProgress.totalUnitCount == 0 && sself.sd_imageProgress.completedUnitCount == 0) {
                sself.sd_imageProgress.totalUnitCount = SDWebImageProgressUnitCountUnknown;
                sself.sd_imageProgress.completedUnitCount = SDWebImageProgressUnitCountUnknown;
            }
            //如果已经完成，或者options设置了不自动赋值图片选项的话，就需要执行完成回调
            BOOL shouldCallCompletedBlock = finished || (options & SDWebImageAvoidAutoSetImage);
            //如果(图片存在 且 options设置了不自动赋值图片这个选项的话) 或者 (图片不存在 且 options没有设置延迟显示placeholder图片选项)的话，就不要将回调中的image设置给当前控件。
            BOOL shouldNotSetImage = ((image && (options & SDWebImageAvoidAutoSetImage)) ||
                                      (!image && !(options & SDWebImageDelayPlaceholder)));
            //为callCompletedBlockClojure赋值
            SDWebImageNoParamsBlock callCompletedBlockClojure = ^{
                if (!sself) { return; }
                if (!shouldNotSetImage) {
                    [sself sd_setNeedsLayout];
                }
                if (completedBlock && shouldCallCompletedBlock) {
                    completedBlock(image, error, cacheType, url);
                }
            };
            
            if (shouldNotSetImage) {
                dispatch_main_async_safe(callCompletedBlockClojure);
                return;
            }
            
            UIImage *targetImage = nil;
            NSData *targetData = nil;
            if (image) {
                targetImage = image;
                targetData = data;
            } else if (options & SDWebImageDelayPlaceholder) {
                targetImage = placeholder;
                targetData = nil;
            }
            
#if SD_UIKIT || SD_MAC
            // 检查是否需要执行图片转换
            SDWebImageTransition *transition = nil;
            //如果已经完成 且 (options设置了强制转换选项 或者 缓存类型为SDImageCacheTypeNone，即没有命中缓存，是从网络获取的图片)的话，就取UIView+WebCache.h头文件中定义的sd_imageTransition转换策略。其实是提供了自定义图片转换的功能，SD默认这个属性是nil。
            if (finished && (options & SDWebImageForceTransition || cacheType == SDImageCacheTypeNone)) {
                transition = sself.sd_imageTransition;
            }
#endif
            //不同宏定义下执行响应的设置方法
            dispatch_main_async_safe(^{
#if SD_UIKIT || SD_MAC
                [sself sd_setImage:targetImage imageData:targetData basedOnClassOrViaCustomSetImageBlock:setImageBlock transition:transition cacheType:cacheType imageURL:imageURL];
#else
                [sself sd_setImage:targetImage imageData:targetData basedOnClassOrViaCustomSetImageBlock:setImageBlock];
#endif
                callCompletedBlockClojure();
            });

说完了block回调，我们进入manager生成operation的方法中一探究竟,即这个方法：

- (id <SDWebImageOperation>)loadImageWithURL:(nullable NSURL *)url
                                     options:(SDWebImageOptions)options
                                    progress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
                                   completed:(nullable SDInternalCompletionBlock)completedBlock 

这个方法的实现代码比较多，我们先把它拆分成以下几个点来逐一研究：

• url参数判断转换
• 判断缓存策略，生成operation的缓存查询操作
• 在operation的缓存查询回调中看是否需要下载

看一下第一部分，我在代码中加了注释，也是比较好理解的：

    //先是一个断言，指明完成回调是必要的参数，否则调用这个方法是没有意义的
    NSAssert(completedBlock != nil, @"If you mean to prefetch the image, use -[SDWebImagePrefetcher prefetchURLs] instead");

    // 防止常见的把NSString当作NSURL传入的错误
    if ([url isKindOfClass:NSString.class]) {
        url = [NSURL URLWithString:(NSString *)url];
    }

    if (![url isKindOfClass:NSURL.class]) {
        url = nil;
    }
    
    SDWebImageCombinedOperation *operation = [SDWebImageCombinedOperation new];
    //operation引用了manager，方便它内部使用。注意operation的manager属性是弱引用，防止引用循环。
    operation.manager = self;

    //查询是否是之前请求过的但是失败了的url，这里用了信号量做锁，下面会详细说一下
    BOOL isFailedUrl = NO;
    if (url) {
        LOCK(self.failedURLsLock);
        isFailedUrl = [self.failedURLs containsObject:url];
        UNLOCK(self.failedURLsLock);
    }

    //如果url长度为空 或者 (options没有设置失败后重试选项 且 是之前请求失败的url) 的话，调用完成回调，回传error。callCompletionBlockForOperation：方法其实没做什么事，最终使用的是一个安全调用block的宏。
    if (url.absoluteString.length == 0 || (!(options & SDWebImageRetryFailed) && isFailedUrl)) {
        [self callCompletionBlockForOperation:operation completion:completedBlock error:[NSError errorWithDomain:NSURLErrorDomain code:NSURLErrorFileDoesNotExist userInfo:nil] url:url];
        return operation;
    }

这里比较有意思的是，查询是否是之前请求过的失败url时，使用了信号量加锁。纵观整个SD，很多地方都使用了这种方法替代互斥锁来保证线程安全。把信号量当做锁其实用法也比较简单，看manager 的 init 方法里，初始化了两个信号量，都是当做锁来用的。

- (nonnull instancetype)initWithCache:(nonnull SDImageCache *)cache downloader:(nonnull SDWebImageDownloader *)downloader {
    if ((self = [super init])) {
        _imageCache = cache;
        _imageDownloader = downloader;
        _failedURLs = [NSMutableSet new];
        _failedURLsLock = dispatch_semaphore_create(1);
        _runningOperations = [NSMutableSet new];
        _runningOperationsLock = dispatch_semaphore_create(1);
    }
    return self;
}
//再看LOCK 和 UNLOCK是什么
#define LOCK(lock) dispatch_semaphore_wait(lock, DISPATCH_TIME_FOREVER);
#define UNLOCK(lock) dispatch_semaphore_signal(lock);

就是初始化一个为1的dispatch_semaphore_t变量，当前operation抢占到资源时，先调用dispatch_semaphore_wait方法将信号量减1，此时dispatch_semaphore_t变量为零，如果再有其他operation想要获取该变量，就只能排队等着，啥时候前一个operation跑完了dispatch_semaphore_signal方法，将信号量加了1。后面的operation才能获取到该信号量进行下一步。当然信号量是一种比较底层的同步机制，不光是当锁用这么简单。这篇文章有各种锁的说明和比较。

接下来是判断缓存策略，生成operation的缓存查询操作：

    //先将当前operation添加到正在进行的所有operation的无序集合中，也用到了前面说的信号量加锁
    LOCK(self.runningOperationsLock);
    [self.runningOperations addObject:operation];
    UNLOCK(self.runningOperationsLock);
    //生成后续查询和存储的key，如果用户自定义了生成key的方法，SD就使用用户自定义的，否则默认为url的absoluteString
    NSString *key = [self cacheKeyForURL:url];
    //获取缓存options
    SDImageCacheOptions cacheOptions = 0;
    if (options & SDWebImageQueryDataWhenInMemory) cacheOptions |= SDImageCacheQueryDataWhenInMemory;
    if (options & SDWebImageQueryDiskSync) cacheOptions |= SDImageCacheQueryDiskSync;
    if (options & SDWebImageScaleDownLargeImages) cacheOptions |= SDImageCacheScaleDownLargeImages;
    //弱引用当前operation
    __weak SDWebImageCombinedOperation *weakOperation = operation;
    operation.cacheOperation = [self.imageCache queryCacheOperationForKey:key options:cacheOptions done:^(UIImage *cachedImage, NSData *cachedData, SDImageCacheType cacheType) {
        __strong __typeof(weakOperation) strongOperation = weakOperation;
        //如果当前operation不存在或者已经被取消，则将其从正在进行的operations无序集合中安全的移除，也用到信号量加锁
        if (!strongOperation || strongOperation.isCancelled) {
            [self safelyRemoveOperationFromRunning:strongOperation];
            return;
        }
        
        // 如果 (options没有设置只从缓存中获取图片选项) 且 (没有命中缓存 或者 options设置了刷新缓存选项) 且 (manager的delegate没有实现imageManager:shouldDownloadImageForURL代理方法 或者 实现了该方法，返回YES) 的话，就需要下载图片
        BOOL shouldDownload = (!(options & SDWebImageFromCacheOnly))
            && (!cachedImage || options & SDWebImageRefreshCached)
            && (![self.delegate respondsToSelector:@selector(imageManager:shouldDownloadImageForURL:)] || [self.delegate imageManager:self shouldDownloadImageForURL:url]);
        if (shouldDownload) {
            if (cachedImage && options & SDWebImageRefreshCached) {
                // 如果命中了缓存，且options设置了刷新缓存选项，那么先执行完成回调，再去请求图片，以刷新NSURLCache的缓存
                [self callCompletionBlockForOperation:strongOperation completion:completedBlock image:cachedImage data:cachedData error:nil cacheType:cacheType finished:YES url:url];
            }

            // 设置后续downloadToken的options
            SDWebImageDownloaderOptions downloaderOptions = 0;
            if (options & SDWebImageLowPriority) downloaderOptions |= SDWebImageDownloaderLowPriority;
            if (options & SDWebImageProgressiveDownload) downloaderOptions |= SDWebImageDownloaderProgressiveDownload;
            if (options & SDWebImageRefreshCached) downloaderOptions |= SDWebImageDownloaderUseNSURLCache;
            if (options & SDWebImageContinueInBackground) downloaderOptions |= SDWebImageDownloaderContinueInBackground;
            if (options & SDWebImageHandleCookies) downloaderOptions |= SDWebImageDownloaderHandleCookies;
            if (options & SDWebImageAllowInvalidSSLCertificates) downloaderOptions |= SDWebImageDownloaderAllowInvalidSSLCertificates;
            if (options & SDWebImageHighPriority) downloaderOptions |= SDWebImageDownloaderHighPriority;
            if (options & SDWebImageScaleDownLargeImages) downloaderOptions |= SDWebImageDownloaderScaleDownLargeImages;
            
            if (cachedImage && options & SDWebImageRefreshCached) {
                downloaderOptions &= ~SDWebImageDownloaderProgressiveDownload;
                downloaderOptions |= SDWebImageDownloaderIgnoreCachedResponse;
            }
            
            //设置operation的downloadToken
            __weak typeof(strongOperation) weakSubOperation = strongOperation;
            strongOperation.downloadToken = [self.imageDownloader downloadImageWithURL:url options:downloaderOptions progress:progressBlock completed:^(UIImage *downloadedImage, NSData *downloadedData, NSError *error, BOOL finished) {   
            xxx（代码没截完）

这段实现的大体逻辑就是，生成operation以后，设置它的缓存查询，在缓存查询的回调中检查是否需要下载图片，如果需要的话，再设置它的downloadToken。也就是先查询缓存，如果没有命中或者设置了刷新缓存选项的话，就去下载图片。那么我们SDImageCache这个工具类中，缓存查询方法是怎么实现的，对照着注释看应该是比较清楚了：

- (nullable NSOperation *)queryCacheOperationForKey:(nullable NSString *)key options:(SDImageCacheOptions)options done:(nullable SDCacheQueryCompletedBlock)doneBlock {
    if (!key) {
        if (doneBlock) {
            doneBlock(nil, nil, SDImageCacheTypeNone);
        }
        return nil;
    }
    
    // 先从内存缓存中查询图片，即从SDImageCache的SDMemoryCache类型的memCache属性中查询，SDMemoryCache继承自NSCache，我记得比较早的SD版本，memCache使用的是NSDictionary。NSCache对比字典有什么优势呢？主要有两点，一是NSCache是线程安全的，另一个是NSCache在内存紧张时，会自动清理部分无用数据。
    UIImage *image = [self imageFromMemoryCacheForKey:key];
    //如果内存中命中了图片，且options没有设置内存中有数据仍旧查询磁盘缓存的选项的话，就直接执行完成回调，并且返回nil。
    BOOL shouldQueryMemoryOnly = (image && !(options & SDImageCacheQueryDataWhenInMemory));
    if (shouldQueryMemoryOnly) {
        if (doneBlock) {
            doneBlock(image, nil, SDImageCacheTypeMemory);
        }
        return nil;
    }
    //如果需要进入磁盘查询，先设置好它的回调block
    NSOperation *operation = [NSOperation new];
    void(^queryDiskBlock)(void) =  ^{
        if (operation.isCancelled) {
            // do not call the completion if cancelled
            return;
        }
        
        @autoreleasepool {
            NSData *diskData = [self diskImageDataBySearchingAllPathsForKey:key];
            UIImage *diskImage;
            SDImageCacheType cacheType = SDImageCacheTypeDisk;
            if (image) {
                // 图片是从内存缓存中命中的
                diskImage = image;
                cacheType = SDImageCacheTypeMemory;
            } else if (diskData) {
                // 图片是从磁盘缓存中命中的
                diskImage = [self diskImageForKey:key data:diskData options:options];
                if (diskImage && self.config.shouldCacheImagesInMemory) {
                    //如果SDImageCache的config设置了shouldCacheImagesInMemory属性，那么将从磁盘命中的图片保存到内存中，方便下次使用。SD默认将该属性置为YES
                    NSUInteger cost = SDCacheCostForImage(diskImage);
                    [self.memCache setObject:diskImage forKey:key cost:cost];
                }
            }
            //如果options设置的是同步查询，就直接执行完成回调；否则，将回调异步提交到主队列。
            if (doneBlock) {
                if (options & SDImageCacheQueryDiskSync) {
                    doneBlock(diskImage, diskData, cacheType);
                } else {
                    dispatch_async(dispatch_get_main_queue(), ^{
                        doneBlock(diskImage, diskData, cacheType);
                    });
                }
            }
        }
    };
    
    if (options & SDImageCacheQueryDiskSync) {
        //如果options设置的是同步查询，就直接执行queryDiskBlock
        queryDiskBlock();
    } else {
        //否则，将block提交到自己的IO队列，SDImageCache初始化时将该队列指定为了串行，只能一个接一个的执行回调
        dispatch_async(self.ioQueue, queryDiskBlock);
    }
    
    return operation;
}

可以看到SD使用的是内存和磁盘的二级缓存，先查询内存，如果命中就直接返回，没有命中的话再查询磁盘缓存；如果磁盘缓存命中，默认会将图片设置到内存缓存中，方便下次使用。同时回调有同步和异步两种选择。缓存查询这块的大体逻辑已经讲完了，我们顺便来看看SDImageCache类中，关于缓存清理这部分的实现逻辑。它在初始化的时候就注册了App将要销毁和进入后台的通知，接到通知以后会自动清理内存,调用删除文件的方法：

- (void)deleteOldFilesWithCompletionBlock:(nullable SDWebImageNoParamsBlock)completionBlock {
    dispatch_async(self.ioQueue, ^{
        NSURL *diskCacheURL = [NSURL fileURLWithPath:self.diskCachePath isDirectory:YES];

        // 确定文件的查询键，是AccessDate 还是ModificationDate
        NSURLResourceKey cacheContentDateKey = NSURLContentModificationDateKey;
        switch (self.config.diskCacheExpireType) {
            case SDImageCacheConfigExpireTypeAccessDate:
                cacheContentDateKey = NSURLContentAccessDateKey;
                break;

            case SDImageCacheConfigExpireTypeModificationDate:
                cacheContentDateKey = NSURLContentModificationDateKey;
                break;

            default:
                break;
        }
        //查询三个信息，是否是文件夹，存入缓存的时间，文件大小
        NSArray<NSString *> *resourceKeys = @[NSURLIsDirectoryKey, cacheContentDateKey, NSURLTotalFileAllocatedSizeKey];

        // 枚举当前路径下的所有文件
        NSDirectoryEnumerator *fileEnumerator = [self.fileManager enumeratorAtURL:diskCacheURL
                                                   includingPropertiesForKeys:resourceKeys
                                                                      options:NSDirectoryEnumerationSkipsHiddenFiles
                                                                 errorHandler:NULL];

        //过期时间，SD默认的文件过期时间是一个星期，如果想自定义的话，可以在SDImageCacheConfig中修改
        NSDate *expirationDate = [NSDate dateWithTimeIntervalSinceNow:-self.config.maxCacheAge];
        NSMutableDictionary<NSURL *, NSDictionary<NSString *, id> *> *cacheFiles = [NSMutableDictionary dictionary];
        NSUInteger currentCacheSize = 0;

        // 这里的for循环有两个目的
        //  1. 将每个过期文件的URL添加到urlsToDelete数组中，后续统一移除对应的文件
        //  2. 将每个文件的信息跟URL对应，存到cacheFiles字典中，后面会用到
        NSMutableArray<NSURL *> *urlsToDelete = [[NSMutableArray alloc] init];
        for (NSURL *fileURL in fileEnumerator) {
            NSError *error;
            NSDictionary<NSString *, id> *resourceValues = [fileURL resourceValuesForKeys:resourceKeys error:&error];

            if (error || !resourceValues || [resourceValues[NSURLIsDirectoryKey] boolValue]) {
                continue;
            }

            NSDate *modifiedDate = resourceValues[cacheContentDateKey];
            if ([[modifiedDate laterDate:expirationDate] isEqualToDate:expirationDate]) {
                [urlsToDelete addObject:fileURL];
                continue;
            }
            
            NSNumber *totalAllocatedSize = resourceValues[NSURLTotalFileAllocatedSizeKey];
            currentCacheSize += totalAllocatedSize.unsignedIntegerValue;
            cacheFiles[fileURL] = resourceValues;
        }
        //移除对应的文件
        for (NSURL *fileURL in urlsToDelete) {
            [self.fileManager removeItemAtURL:fileURL error:nil];
        }

        // 如果用户设置了最大磁盘缓存尺寸，且当前缓存尺寸超过了设置的最大值。注意SD默认是没有设置最大磁盘缓存的。
        if (self.config.maxCacheSize > 0 && currentCacheSize > self.config.maxCacheSize) {
            // 设置此次的目标尺寸为最大尺寸的一半
            const NSUInteger desiredCacheSize = self.config.maxCacheSize / 2;

            // 根据文件修改时间将其排序，最老的文件在最前面，也就是说最先删除
            NSArray<NSURL *> *sortedFiles = [cacheFiles keysSortedByValueWithOptions:NSSortConcurrent
                                                                     usingComparator:^NSComparisonResult(id obj1, id obj2) {
                                                                         return [obj1[NSURLContentModificationDateKey] compare:obj2[NSURLContentModificationDateKey]];
                                                                     }];

            // Delete files until we fall below our desired cache size.
            for (NSURL *fileURL in sortedFiles) {
                if ([self.fileManager removeItemAtURL:fileURL error:nil]) {
                    NSDictionary<NSString *, id> *resourceValues = cacheFiles[fileURL];
                    NSNumber *totalAllocatedSize = resourceValues[NSURLTotalFileAllocatedSizeKey];
                    currentCacheSize -= totalAllocatedSize.unsignedIntegerValue;

                    if (currentCacheSize < desiredCacheSize) {
                        break;
                    }
                }
            }
        }
        if (completionBlock) {
            dispatch_async(dispatch_get_main_queue(), ^{
                completionBlock();
            });
        }
    });
}

所以每次App进入后台，SD都会检查，如果磁盘中存在过期文件则删除；同时如果用户设置了最大磁盘缓存尺寸，且已经使用的磁盘大小超过了这个阈值，会以最大值的一半作为此次清理的目标，从最老的文件开始删，直到达到目标尺寸。
说完缓存查询这部分，我们回到operation生成downloadToken这里。其实调用的是SDWebImageDownloader这个工具类来生成downloadToken：

- (nullable SDWebImageDownloadToken *)downloadImageWithURL:(nullable NSURL *)url
                                                   options:(SDWebImageDownloaderOptions)options
                                                  progress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
                                                 completed:(nullable SDWebImageDownloaderCompletedBlock)completedBlock {
    __weak SDWebImageDownloader *wself = self;

    return [self addProgressCallback:progressBlock completedBlock:completedBlock forURL:url createCallback:^SDWebImageDownloaderOperation *{
        __strong __typeof (wself) sself = wself;
        NSTimeInterval timeoutInterval = sself.downloadTimeout;

该方法中最主要的是实现了名叫createCallback的回调block，因为其实一个URL对应一个下载操作，如果多个控件使用了同一个URL下载，是没有必要下载多次的。所以SD会在addProgressCallback：completedBlock：forURL：createCallback：方法中判断是否已经存在了当前URL对应的下载操作，不存在的话再调用createCallback创建。创建下载操作其实就是按部就班的设置超时时间(SD默认15秒)、根据缓存策略生成request、设置request的头信息；然后根据request创建对应的SDWebImageDownloaderOperation，然后把SDWebImageDownloader这个工具类的证书验证及操作优先级等属性赋值给它生成的每个SDWebImageDownloaderOperation。在方法的最后，有这样一个if判断：

if (sself.executionOrder == SDWebImageDownloaderLIFOExecutionOrder) {
            // 用户可以设置下载操作的执行顺序，如果设置了LIFO(Last In First Out)的话，会将前一个下载操作依赖当前下载操作，保证了最后生成的下载操作会最先执行
            [sself.lastAddedOperation addDependency:operation];
            sself.lastAddedOperation = operation;
        }

这里稍微引申一下，iOS中最常用的多线程编程方法应该就是NSOperation和GCD了吧，这里可以看到NSOperation对比GCD的一个优点：添加依赖非常方便。当然还有另外的优点比如提交的操作可以取消，可以设置操作的优先级等。所以要根据不同的应用场景选择最合适的工具。我们接着看addProgressCallback：completedBlock：forURL：createCallback：方法：

- (nullable SDWebImageDownloadToken *)addProgressCallback:(SDWebImageDownloaderProgressBlock)progressBlock
                                           completedBlock:(SDWebImageDownloaderCompletedBlock)completedBlock
                                                   forURL:(nullable NSURL *)url
                                           createCallback:(SDWebImageDownloaderOperation *(^)(void))createCallback {
    // 因为URL后续会当做保存下载操作的字典查询的key，所以必须保证不为空。
    if (url == nil) {
        if (completedBlock != nil) {
            completedBlock(nil, nil, nil, NO);
        }
        return nil;
    }
    //同步查询字典中是否存在该url对应的操作
    LOCK(self.operationsLock);
    SDWebImageDownloaderOperation *operation = [self.URLOperations objectForKey:url];
    //如果不存在 或者 操作已经标记为完成
    if (!operation || operation.isFinished) {
        operation = createCallback();
        __weak typeof(self) wself = self;
        operation.completionBlock = ^{
            __strong typeof(wself) sself = wself;
            if (!sself) {
                return;
            }
            //operation的完成回调中会将自己从URLOperations字典中移除
            LOCK(sself.operationsLock);
            [sself.URLOperations removeObjectForKey:url];
            UNLOCK(sself.operationsLock);
        };
        [self.URLOperations setObject:operation forKey:url];

        [self.downloadQueue addOperation:operation];
    }
    UNLOCK(self.operationsLock);
    //将progressBlock和completeBlock赋值给cancelToken
    id downloadOperationCancelToken = [operation addHandlersForProgress:progressBlock completed:completedBlock];
    //生成downloadToken
    SDWebImageDownloadToken *token = [SDWebImageDownloadToken new];
    token.downloadOperation = operation;
    token.url = url;
    token.downloadOperationCancelToken = downloadOperationCancelToken;

    return token;
}

可以看到，从最外层传入的progressBlock 和 completeBlock 最终都赋值给了cancelToken，我们进入该方法看看：

- (nullable id)addHandlersForProgress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
                            completed:(nullable SDWebImageDownloaderCompletedBlock)completedBlock {
    SDCallbacksDictionary *callbacks = [NSMutableDictionary new];
    if (progressBlock) callbacks[kProgressCallbackKey] = [progressBlock copy];
    if (completedBlock) callbacks[kCompletedCallbackKey] = [completedBlock copy];
    LOCK(self.callbacksLock);
    [self.callbackBlocks addObject:callbacks];
    UNLOCK(self.callbacksLock);
    return callbacks;
}

就是将两个回调先用字典装起来，然后添加到callbackBlocks数组中。这里我刚开始看的时候有个疑问，不是一个url对应一个下载吗，为什么SDWebImageDownloaderOperation内部的回调会是个数组呢？后来才想明白，就跟上面说的一样，如果多个控件短时间内加载同一个url，先加载的那个控件生成了一个下载操作，后续就没必要再生成下载操作了，但是回调是必须区分的，因为每个控件的完成回调中，会把图片赋值给当前控件。所以内部的回调要用一个数组来装载，图片下载完成以后依次调用每个回调。

最终的下载操作都是SDWebImageDownloaderOperation这个类实现的。我们知道使用NSOperation实现多线程的话，只有两种方法，一是使用它的子类：NSInvocationOperation 或者 NSBlockOperation；另外就是自定义一个类，继承自NSOperation，覆写它的start方法。可以看到SD使用的是后面一个方法。我们看看它的start方法里都做了些什么：

- (void)start {
     //一般都是在start方法开始的时候就检测当前操作是否被取消。
    @synchronized (self) {
        if (self.isCancelled) {
            self.finished = YES;
            [self reset];
            return;
        }

//iOS和tvOS都可以在App进入后台后向系统申请额外的操作时间
#if SD_UIKIT
        Class UIApplicationClass = NSClassFromString(@"UIApplication");
        BOOL hasApplication = UIApplicationClass && [UIApplicationClass respondsToSelector:@selector(sharedApplication)];
        if (hasApplication && [self shouldContinueWhenAppEntersBackground]) {
            __weak __typeof__ (self) wself = self;
            UIApplication * app = [UIApplicationClass performSelector:@selector(sharedApplication)];
            self.backgroundTaskId = [app beginBackgroundTaskWithExpirationHandler:^{
                __strong __typeof (wself) sself = wself;

                if (sself) {
                    [sself cancel];

                    [app endBackgroundTask:sself.backgroundTaskId];
                    sself.backgroundTaskId = UIBackgroundTaskInvalid;
                }
            }];
        }
#endif
        NSURLSession *session = self.unownedSession;
        if (!session) {
            NSURLSessionConfiguration *sessionConfig = [NSURLSessionConfiguration defaultSessionConfiguration];
            sessionConfig.timeoutIntervalForRequest = 15;
            //如果外部没有赋值session给它，那么就自己在内部生成一个，并赋值给ownedSession，
            session = [NSURLSession sessionWithConfiguration:sessionConfig
                                                    delegate:self
                                               delegateQueue:nil];
            self.ownedSession = session;
        }
        
        if (self.options & SDWebImageDownloaderIgnoreCachedResponse) {
            // Grab the cached data for later check
            NSURLCache *URLCache = session.configuration.URLCache;
            if (!URLCache) {
                URLCache = [NSURLCache sharedURLCache];
            }
            NSCachedURLResponse *cachedResponse;
            // SD特别指明了 URLCache 的 cachedResponseForRequest：方法不是线程安全的
            @synchronized (URLCache) {
                cachedResponse = [URLCache cachedResponseForRequest:self.request];
            }
            if (cachedResponse) {
                self.cachedData = cachedResponse.data;
            }
        }
        
        self.dataTask = [session dataTaskWithRequest:self.request];
        self.executing = YES;
    }

    if (self.dataTask) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunguarded-availability"
        if ([self.dataTask respondsToSelector:@selector(setPriority:)]) {
            //设定dataTask的优先级
            if (self.options & SDWebImageDownloaderHighPriority) {
                self.dataTask.priority = NSURLSessionTaskPriorityHigh;
            } else if (self.options & SDWebImageDownloaderLowPriority) {
                self.dataTask.priority = NSURLSessionTaskPriorityLow;
            }
        }
#pragma clang diagnostic pop
        [self.dataTask resume];
        //调用progress回调
        for (SDWebImageDownloaderProgressBlock progressBlock in [self callbacksForKey:kProgressCallbackKey]) {
            progressBlock(0, NSURLResponseUnknownLength, self.request.URL);
        }
        __weak typeof(self) weakSelf = self;
        //回调主线程发送开始下载的通知
        dispatch_async(dispatch_get_main_queue(), ^{
            [[NSNotificationCenter defaultCenter] postNotificationName:SDWebImageDownloadStartNotification object:weakSelf];
        });
    } else {
        //如果没有生成dataTask，则调用完成回调，并传递error
        [self callCompletionBlocksWithError:[NSError errorWithDomain:NSURLErrorDomain code:NSURLErrorUnknown userInfo:@{NSLocalizedDescriptionKey : @"Task can't be initialized"}]];
        [self done];
        return;
    }

#if SD_UIKIT
    Class UIApplicationClass = NSClassFromString(@"UIApplication");
    if(!UIApplicationClass || ![UIApplicationClass respondsToSelector:@selector(sharedApplication)]) {
        return;
    }
    if (self.backgroundTaskId != UIBackgroundTaskInvalid) {
        UIApplication * app = [UIApplication performSelector:@selector(sharedApplication)];
        [app endBackgroundTask:self.backgroundTaskId];
        self.backgroundTaskId = UIBackgroundTaskInvalid;
    }
#endif
}

最后，我们再来看看SDWebImageManager中调用imageDownloader工具类生成downloadToken的完成回调中做了什么事情：

__weak typeof(strongOperation) weakSubOperation = strongOperation;
            strongOperation.downloadToken = [self.imageDownloader downloadImageWithURL:url options:downloaderOptions progress:progressBlock completed:^(UIImage *downloadedImage, NSData *downloadedData, NSError *error, BOOL finished) {
                __strong typeof(weakSubOperation) strongSubOperation = weakSubOperation;
                if (!strongSubOperation || strongSubOperation.isCancelled) {
                    // 如果strongSubOperation为空，或者被取消了，什么都不做
                } else if (error) {
                  //如果产生错误，则执行完成回调，并回传错误
                    [self callCompletionBlockForOperation:strongSubOperation completion:completedBlock error:error url:url];
                    BOOL shouldBlockFailedURL;
                    // 检查是否需要将当前的url放到请求失败的url数组中
                    if ([self.delegate respondsToSelector:@selector(imageManager:shouldBlockFailedURL:withError:)]) {
                        shouldBlockFailedURL = [self.delegate imageManager:self shouldBlockFailedURL:url withError:error];
                    } else {
                        shouldBlockFailedURL = (   error.code != NSURLErrorNotConnectedToInternet
                                                && error.code != NSURLErrorCancelled
                                                && error.code != NSURLErrorTimedOut
                                                && error.code != NSURLErrorInternationalRoamingOff
                                                && error.code != NSURLErrorDataNotAllowed
                                                && error.code != NSURLErrorCannotFindHost
                                                && error.code != NSURLErrorCannotConnectToHost
                                                && error.code != NSURLErrorNetworkConnectionLost);
                    }
                    
                    if (shouldBlockFailedURL) {
                        LOCK(self.failedURLsLock);
                        [self.failedURLs addObject:url];
                        UNLOCK(self.failedURLsLock);
                    }
                }
                else {
                    //一切正常的话就走到这里
                    if ((options & SDWebImageRetryFailed)) {
                    //如果options设置了SDWebImageRetryFailed选项，就把当前url从failedURLs中移除。因为有可能多次请求一个url，前面请求失败的话，就被添加到这个数组中了。请求成功的时候需要移除。
                        LOCK(self.failedURLsLock);
                        [self.failedURLs removeObject:url];
                        UNLOCK(self.failedURLsLock);
                    }
                    
                    BOOL cacheOnDisk = !(options & SDWebImageCacheMemoryOnly);
                    
                    // SD自己的manager是默认实现了缩放处理的，如果使用的是用户自己的manager就走下面这步进行缩放处理
                    if (self != [SDWebImageManager sharedManager] && self.cacheKeyFilter && downloadedImage) {
                        downloadedImage = [self scaledImageForKey:key image:downloadedImage];
                    }

                    if (options & SDWebImageRefreshCached && cachedImage && !downloadedImage) {
                        // Image refresh hit the NSURLCache cache, do not call the completion block
                    } else if (downloadedImage && (!downloadedImage.images || (options & SDWebImageTransformAnimatedImage)) && [self.delegate respondsToSelector:@selector(imageManager:transformDownloadedImage:withURL:)]) {
                            //异步执行图片转换操作
                            dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
                            UIImage *transformedImage = [self.delegate imageManager:self transformDownloadedImage:downloadedImage withURL:url];

                            if (transformedImage && finished) {
                                BOOL imageWasTransformed = ![transformedImage isEqual:downloadedImage];
                                NSData *cacheData;
                                // pass nil if the image was transformed, so we can recalculate the data from the image
                                if (self.cacheSerializer) {
                                    cacheData = self.cacheSerializer(transformedImage, (imageWasTransformed ? nil : downloadedData), url);
                                } else {
                                    cacheData = (imageWasTransformed ? nil : downloadedData);
                                }
                                [self.imageCache storeImage:transformedImage imageData:cacheData forKey:key toDisk:cacheOnDisk completion:nil];
                            }
                            
                            [self callCompletionBlockForOperation:strongSubOperation completion:completedBlock image:transformedImage data:downloadedData error:nil cacheType:SDImageCacheTypeNone finished:finished url:url];
                        });
                    } else {
                        if (downloadedImage && finished) {
                            //如果用户自定义了图片的缓存处理方法
                            if (self.cacheSerializer) {
                                dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
                                    NSData *cacheData = self.cacheSerializer(downloadedImage, downloadedData, url);
                                    [self.imageCache storeImage:downloadedImage imageData:cacheData forKey:key toDisk:cacheOnDisk completion:nil];
                                });
                            } else {
                                //将图片存入缓存
                                [self.imageCache storeImage:downloadedImage imageData:downloadedData forKey:key toDisk:cacheOnDisk completion:nil];
                            }
                        }
                        //调用最终的完成回调
                        [self callCompletionBlockForOperation:strongSubOperation completion:completedBlock image:downloadedImage data:downloadedData error:nil cacheType:SDImageCacheTypeNone finished:finished url:url];
                    }
                }

                if (finished) {
                    //如果操作完成，将当前操作从保存的正在运行的操作数组中移除
                    [self safelyRemoveOperationFromRunning:strongSubOperation];
                }
            }];

至此，SD的所有主流程我们都梳理了一遍。这一路的参数传递及各种block回调，刚开始看的时候确实会比较懵逼。但是只要静下心来，对照着源码耐心研读，最终一定会融会贯通的。当然，SD还有一些其他的模块，我自己也没有仔细去看，就不班门弄斧了。第三方源码的解读确实是比较花时间，特别是想自己写一篇比较全面的总结得时候就更加需要耐心了。一不小心这篇总结就差不多花了我周末两天时间，已经周日下午三点多，是时候抓住周末的尾巴啦~就酱，溜了溜了。。。

嚣张.jpg

参考资料：
https://knightsj.github.io/2018/02/03/SDWebImage%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90/
https://www.jianshu.com/p/9e97c11aeea9