SDWebImage源码阅读(六)SDImageCacheConfig/SDImageCache(下)

　　在上篇中已经了解分析了 SDImageCache.h 文件中所有的方法和属性。大概对 SDImageCache 能实现的功能已经有了全面的认识。在这篇则着重学习研究这些功能的实现过程和实现原理。

　　SDImageCache  是 SDWebImage 里面用来做缓存的类，虽然只是针对的图片的缓存，但是其实在 iOS 开发甚至在程序开发中，缓存类对缓存文件的类型区别而要单独针对文件类型做处理的需要并不多，不管是图片的缓存还是别的类型文件的缓存，它们在缓存原理上是基本一致的。通过对 SDImageCache 针对图片的缓存处理的实现的学习，在以后有开发需求要做别的类型文件的缓存处理的时候，都可以对其模仿和学习，创建类似的缓存管理类。

　　下面开始学习 SDImageCache.m 的代码：

　　首先是在 SDImageCache.m 内部嵌套定义了一个继承自 NSCache 的类 AutoPurgeCache。

　　NSCache 在收到内存警告的时候会释放自身的一部分资源，而设计 AutoPurgeCache 的目的是，在收到内存警告的时候，释放内存缓存中的所有资源。

　　AutoPurgeCache 类 .h/.m 全部的内容:

// See https://github.com/rs/SDWebImage/pull/1141 for discussion
@interface AutoPurgeCache : NSCache
@end

@implementation AutoPurgeCache

- (nonnull instancetype)init {
    self = [super init];
    if (self) {
#if SD_UIKIT
        [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(removeAllObjects) name:UIApplicationDidReceiveMemoryWarningNotification object:nil];
#endif
    }
    return self;
}

- (void)dealloc {
#if SD_UIKIT
    [[NSNotificationCenter defaultCenter] removeObserver:self name:UIApplicationDidReceiveMemoryWarningNotification object:nil];
#endif
}

@end

　　 如果是当前开发平台包含 UIKit框架，在 AutoPurgeCache 类的 init 方法里面添加一个名字为 

UIApplicationDidReceiveMemoryWarningNotification 的通知，接收到通知的时候执行 

removeAllObjects 方法，删除缓存的所有资源。

　　在该类的 dealloc  方法里面，移除名字是

UIApplicationDidReceiveMemoryWarningNotification 的通知。

　　UIApplicationDidReceiveMemoryWarningNotification 是定义在 UIApplication.h 里面的一个不可变的字符串常量：

UIKIT_EXTERN NSNotificationName const UIApplicationDidReceiveMemoryWarningNotification;

2 typedef NSString *NSNotificationName NS_EXTENSIBLE_STRING_ENUM;

　　当应用程序接收到内存警告是会发送该通知，让应用程序清理内存。

 

　　接下来学习一下 NSCache 这个类：

　　NSCache 是包含在 Foundation  框架里面的一个类，它的 .h 全部代码才 40 多行：

#import <Foundation/NSObject.h>

@class NSString;
@protocol NSCacheDelegate;

NS_ASSUME_NONNULL_BEGIN

NS_CLASS_AVAILABLE(10_6, 4_0)
@interface NSCache <KeyType, ObjectType> : NSObject {
@private
    id _delegate;
    void *_private[5];
    void *_reserved;
}

@property (copy) NSString *name;

@property (nullable, assign) id<NSCacheDelegate> delegate;

- (nullable ObjectType)objectForKey:(KeyType)key;
- (void)setObject:(ObjectType)obj forKey:(KeyType)key; // 0 cost
- (void)setObject:(ObjectType)obj forKey:(KeyType)key cost:(NSUInteger)g;
- (void)removeObjectForKey:(KeyType)key;

- (void)removeAllObjects;

@property NSUInteger totalCostLimit;    // limits are imprecise/not strict
@property NSUInteger countLimit;    // limits are imprecise/not strict
@property BOOL evictsObjectsWithDiscardedContent;

@end

@protocol NSCacheDelegate <NSObject>
@optional
- (void)cache:(NSCache *)cache willEvictObject:(id)obj;
@end

NS_ASSUME_NONNULL_END

 　

　　NSCache 简要介绍:

　　NSCache 是官方提供的缓存类，具体的使用和 NSMutableDictionary 类似，在 AFNetWorking 和 SDWebImage 里面用来管理缓存。

　　NSCache 在系统内存很低时，会自动释放对象（模拟器不会释放），建议在接收到内存警告时主动调用 removeAllObject 方法释放对象。

　　NSCache 是线程安全的，在多线程操作的时候，不需要对 NSCache 加锁。

　　NSCache 的 key 只是对对象进行 Strong 引用，不是拷贝，在清理的时候计算的是实际大小而不是引用的大小。

　　NSCache 具有自动删除的功能，以减少系统占用的内存。

　　NSCache 的键对象不会像 NSMutableDictionary 中那样被复制。（键不需要实现 NSCopying 协议）

 

　　NSCache 的属性和方法:

@property NSUInteger totalCostLimit;    // limits are imprecise/not strict

　　totalCostLimit 设置缓存占用的内存大小，并不是一个严格限制，当内存占用超过了 totalCostLimit 设定的值，系统会清空一部分缓存，直至总消耗低于 totalCostLimit  的值。默认值是 0 ，表示没有限制。

@property (copy) NSString *name;

　　名称。

@property (nullable, assign) id<NSCacheDelegate> delegate;

　　设置代理。

@property NSUInteger countLimit;    // limits are imprecise/not strict

　　countLimit 能够缓存的对象的最大数量，这也不是一个严格的控制。默认值是 0，表示没有限制。

@property BOOL evictsObjectsWithDiscardedContent;

　　evictsObjectsWithDiscardedContent 用来标识缓存是否自动舍弃那些内存已经被丢弃的对象（默认该属性为 YES），如果为 YES，则在对象的内存被丢弃时舍弃对象。标识缓存是否回收废弃的内容。

- (nullable ObjectType)objectForKey:(KeyType)key;

　　获取缓存对象，基于 key-value 对。

- (void)setObject:(ObjectType)obj forKey:(KeyType)key; // 0 cost

　　在缓存中设置指定键名对应的值存储，考虑缓存的限制属性。

- (void)setObject:(ObjectType)obj forKey:(KeyType)key cost:(NSUInteger)g;

　　在缓存中设置指定键名对应的值存储，cost 是提前知道该缓存对象占用的字节数，用于计算记录在缓存中的所有对象的缓存大小，也会考虑缓存的限制属性，建议直接使用上个没有 cost 参数的方法。

 

　　当出现内存警告或者超出缓存限制的时候，缓存会开启一个回收过程删除部分对象，释放内存。

- (void)removeObjectForKey:(KeyType)key;

　　删除缓存中指定键名的对象。

- (void)removeAllObjects;

　　删除缓存中所有的对象。

 

　　NSCacheDelegate 代理

@protocol NSCacheDelegate <NSObject>
@optional
- (void)cache:(NSCache *)cache willEvictObject:(id)obj;
@end

　　实现 NSCacheDelegate 代理的对象，在缓存对象即将被清理的时候，系统回调代理方法。

　　第一个参数:是当前的缓存（NSCache），不要修改该对象。

　　第二个参数:是当前将要被清理的对象，如果需要存储该对象，可以在这里操作（把该对象存入 Sqlite 或者 CoreData）。

　　该代理方法会在缓存对象即将被清理的时候调用，如下场景会调用:

　　1. 使用 - (void)removeObjectForKey:(KeyType)key; 手动删除指定对象的时候。

　　2.缓存对象超过了 NSCache 的属性限制（totalCostLimit  和 countLimit）。

　　3.App 进入后台的时候会调用。

　　4.系统发出内存警告的时候（UIApplicationDidReceiveMemoryWarningNotification）。

 

　　下面接着看 SDImageCache.m 的代码:

　　计算一个 UIImage 的 SDCacheCostForImage(UIImage *image)

 　　图片在缓存中的大小是通过像素来衡量的。

FOUNDATION_STATIC_INLINE NSUInteger SDCacheCostForImage(UIImage *image) {
#if SD_MAC
    return image.size.height * image.size.width;
#elif SD_UIKIT || SD_WATCH
    return image.size.height * image.size.width * image.scale * image.scale;
#endif
}

　　FOUNDATION_STATIC_INLINE

#if !defined(FOUNDATION_STATIC_INLINE)
#define FOUNDATION_STATIC_INLINE static __inline__
#endif

　　FOUNDATION_STATIC_INLINE 是 Foundation 框架中 NSObjCRuntime.h 里面定义内联函数的前缀修饰符。

　　static __inline__ 表示该函数是一个具有文件内部访问权限的内联函数，所谓的内联函数就是建议编译器在调用时将函数展开。建议的意思就是说编译器不一定会按照你的建议做。因此内联函数尽量不要写的太复杂。

　　Properties 

#pragma mark - Properties
@property (strong, nonatomic, nonnull) NSCache *memCache;
@property (strong, nonatomic, nonnull) NSString *diskCachePath;
@property (strong, nonatomic, nullable) NSMutableArray<NSString *> *customPaths;
@property (SDDispatchQueueSetterSementics, nonatomic, nullable) dispatch_queue_t ioQueue;

@implementation SDImageCache {
    NSFileManager *_fileManager;
}

　　memCache NSCache 类型的变量，表示内存容器。

　　diskCachePath 这个应该能望名知意，表示磁盘缓存的路径。

　　customPaths 这是一个里面存放 NSString 的字符串可变数组，表示里面存放的都是自定义的缓存路径，当扫描图片和向磁盘缓存图片的时候要用到这些指定的路径。- (void)addReadOnlyCachePath:(nonnull NSString *)path;  这个方法即向 customPaths 数组里面添加自定义的路径，当读取图片的时候，customPaths 数组里面的所有路径都会被扫描。

　　ioQueue 这是用于输入和输出的队列，队列其实往往可以当做一种"锁"来使用，把某些任务放在串行队列里面按照顺序一步一步的执行，必须考虑线程是否安全。

　　_fileManager 表示一个 NSFileManager 文件管理者。

　　Singleton, init, dealloc

#pragma mark - Singleton, init, dealloc

+ (nonnull instancetype)sharedImageCache {
    static dispatch_once_t once;
    static id instance;
    dispatch_once(&once, ^{
        instance = [self new];
    });
    return instance;
}

- (instancetype)init {
    return [self initWithNamespace:@"default"];
}

- (nonnull instancetype)initWithNamespace:(nonnull NSString *)ns {
    NSString *path = [self makeDiskCachePath:ns];
    return [self initWithNamespace:ns diskCacheDirectory:path];
}

- (nonnull instancetype)initWithNamespace:(nonnull NSString *)ns
                       diskCacheDirectory:(nonnull NSString *)directory {
    if ((self = [super init])) {
        NSString *fullNamespace = [@"com.hackemist.SDWebImageCache." stringByAppendingString:ns];
        
        // Create IO serial queue
        _ioQueue = dispatch_queue_create("com.hackemist.SDWebImageCache", DISPATCH_QUEUE_SERIAL);
        
        _config = [[SDImageCacheConfig alloc] init];
        
        // Init the memory cache
        _memCache = [[AutoPurgeCache alloc] init];
        _memCache.name = fullNamespace;

        // Init the disk cache
        if (directory != nil) {
            _diskCachePath = [directory stringByAppendingPathComponent:fullNamespace];
        } else {
            NSString *path = [self makeDiskCachePath:ns];
            _diskCachePath = path;
        }

        dispatch_sync(_ioQueue, ^{
            _fileManager = [NSFileManager new];
        });

#if SD_UIKIT
        // Subscribe to app events
        [[NSNotificationCenter defaultCenter] addObserver:self
                                                 selector:@selector(clearMemory)
                                                     name:UIApplicationDidReceiveMemoryWarningNotification
                                                   object:nil];

        [[NSNotificationCenter defaultCenter] addObserver:self
                                                 selector:@selector(deleteOldFiles)
                                                     name:UIApplicationWillTerminateNotification
                                                   object:nil];

        [[NSNotificationCenter defaultCenter] addObserver:self
                                                 selector:@selector(backgroundDeleteOldFiles)
                                                     name:UIApplicationDidEnterBackgroundNotification
                                                   object:nil];
#endif
    }

    return self;
}

- (void)dealloc {
    [[NSNotificationCenter defaultCenter] removeObserver:self];
    SDDispatchQueueRelease(_ioQueue);
}

- (void)checkIfQueueIsIOQueue {
    const char *currentQueueLabel = dispatch_queue_get_label(DISPATCH_CURRENT_QUEUE_LABEL);
    const char *ioQueueLabel = dispatch_queue_get_label(self.ioQueue);
    if (strcmp(currentQueueLabel, ioQueueLabel) != 0) {
        NSLog(@"This method should be called from the ioQueue");
    }
}

　　这一部分的代码，首先时单例方法 + (nonnull instancetype)sharedImageCache

的实现，在 dispatch_once_t 中创建全程序使用的 SDWebCache 类。下面是 SDWebImage 的三个初始化方法，方法1 和 方法2 最终都会调用方法3 完成初始化。下面着重看一下方法3 的初始化过程：

　　- (nonnull instancetype)initWithNamespace:(nonnull NSString *)ns

                       diskCacheDirectory:(nonnull NSString *)directory{}

        NSString *fullNamespace = [@"com.hackemist.SDWebImageCache." stringByAppendingString:ns];

　　@"com.hackemist.SDWebImageCache."  与传入的 Namespace 拼接成完整的命名空间赋值给字符串变量 fullNamespace，使用 init 初始化方法时 Namespace 默认使用 @"default"，此时 fullNamespace 值等于 @"com.hackemist.SDWebImageCache.default"。

        // Create IO serial queue
        _ioQueue = dispatch_queue_create("com.hackemist.SDWebImageCache", DISPATCH_QUEUE_SERIAL);

　　初始化串行队列 _ioQueue。

_config = [[SDImageCacheConfig alloc] init];

　　初始化 SDImageCache 的配置类 _config。（SDImageCacheConfig 类）

       // Init the memory cache
        _memCache = [[AutoPurgeCache alloc] init];
        _memCache.name = fullNamespace;

　　初始化 _memCache（AutoPurgeCache 类），并把 fullNameSpace 赋值为 _memCache 的 name 属性。_memCache 的主要作用是当收到内存警告的时候，释放内存中与 SDWebImage 相关的缓存中的所有资源。

        // Init the disk cache
        if (directory != nil) {
            _diskCachePath = [directory stringByAppendingPathComponent:fullNamespace];
        } else {
            NSString *path = [self makeDiskCachePath:ns];
            _diskCachePath = path;
        }

        dispatch_sync(_ioQueue, ^{
            _fileManager = [NSFileManager new];
        });

　　判断 directory 是否为 nil，directory 是没有拼接 fullNamespace 的磁盘缓存的路径，不为空的时候（自定义的缓存路径，默认的是存在 Library 下的 Caches 文件夹里面）就直接拼接 fullNamespace，这里需要注意一下 - (NSString *)stringByAppendingPathComponent:(NSString *)str; 这个方法是 Foundation 框架下的 NSPathUtilities 类下面的方法，它会自动在 directory 末尾和 fullNamespace 中间加 "/"。当 directory 为 nil 的时候，path 是默认的路径，即系统 Library 下的 Caches 拼接 fullNamespace 组成的路径。

//  /Users/jay/Library/Developer/CoreSimulator/Devices/74A07152-3D06-44F3-9DE6-C4B1778BC448/data/Containers/Data/Application/647E08DA-FAED-49F8-A36C-765962B83117/Library/Caches/com.hackemist.SDWebImageCache.default

　　在 _ioQueue 队列同步初始化 _fileManager。 

#if SD_UIKIT
        // Subscribe to app events
        [[NSNotificationCenter defaultCenter] addObserver:self
                                                 selector:@selector(clearMemory)
                                                     name:UIApplicationDidReceiveMemoryWarningNotification
                                                   object:nil];

        [[NSNotificationCenter defaultCenter] addObserver:self
                                                 selector:@selector(deleteOldFiles)
                                                     name:UIApplicationWillTerminateNotification
                                                   object:nil];

        [[NSNotificationCenter defaultCenter] addObserver:self
                                                 selector:@selector(backgroundDeleteOldFiles)
                                                     name:UIApplicationDidEnterBackgroundNotification
                                                   object:nil];
#endif

　　这里判断是否 SD_UIKIT 为真，即当前的开发平台是 iOS 或者 TV，如果为真添加了三个监听通知，

　　当发送 UIApplicationDidReceiveMemoryWarningNotification 通知时执行 clearMemory，

　　当发送 UIApplicationWillTerminateNotification（程序将要结束时）通知时执行 deleteOldFiles，

　　当发送 UIApplicationDidEnterBackgroundNotification （程序进入后台）通知时执行 

backgroundDeleteOldFiles。

- (void)dealloc {
    [[NSNotificationCenter defaultCenter] removeObserver:self];
    SDDispatchQueueRelease(_ioQueue);
} 

　　在 SDImageCache  类销毁的时候，移除所有的通知，SDDispatchQueueRelease 是在 SDWebImageCompat 里面定义的用来将 GCD 对象释放的宏，GCD 中的对象在 iOS 6.0 之前是不参与 ARC 的，而在 6.0 之后，在 ARC 下使用 GCD 是不用关心释放问题。

- (void)checkIfQueueIsIOQueue {
    const char *currentQueueLabel = dispatch_queue_get_label(DISPATCH_CURRENT_QUEUE_LABEL);
    const char *ioQueueLabel = dispatch_queue_get_label(self.ioQueue);
    if (strcmp(currentQueueLabel, ioQueueLabel) != 0) {
        NSLog(@"This method should be called from the ioQueue");
    }
}

　　使用 dispatch_queue_get_label 返回创建队列时的添加的自定义的队列的标识（const char *_Nullable label），主队列返回的是: "com.apple.main-thread"。_ioQueue 返回的是 "com.hackemist.SDWebImageCache"，使用 DISPATCH_CURRENT_QUEUE_LABEL 做参数可返回当前队列的标识。由此检查当前队列是不是 _ioQueue。

　　Cache paths

#pragma mark - Cache paths

- (void)addReadOnlyCachePath:(nonnull NSString *)path {
    if (!self.customPaths) {
        self.customPaths = [NSMutableArray new];
    }

    if (![self.customPaths containsObject:path]) {
        [self.customPaths addObject:path];
    }
}

- (nullable NSString *)cachePathForKey:(nullable NSString *)key inPath:(nonnull NSString *)path {
    NSString *filename = [self cachedFileNameForKey:key];
    return [path stringByAppendingPathComponent:filename];
}

- (nullable NSString *)defaultCachePathForKey:(nullable NSString *)key {
    return [self cachePathForKey:key inPath:self.diskCachePath];
}

- (nullable NSString *)cachedFileNameForKey:(nullable NSString *)key {
    const char *str = key.UTF8String;
    if (str == NULL) {
        str = "";
    }
    unsigned char r[CC_MD5_DIGEST_LENGTH];
    CC_MD5(str, (CC_LONG)strlen(str), r);
    NSString *filename = [NSString stringWithFormat:@"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%@",
                          r[0], r[1], r[2], r[3], r[4], r[5], r[6], r[7], r[8], r[9], r[10],
                          r[11], r[12], r[13], r[14], r[15], [key.pathExtension isEqualToString:@""] ? @"" : [NSString stringWithFormat:@".%@", key.pathExtension]];

    return filename;
}

- (nullable NSString *)makeDiskCachePath:(nonnull NSString*)fullNamespace {
    NSArray<NSString *> *paths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES);
    return [paths[0] stringByAppendingPathComponent:fullNamespace];
}

　　这一部分的代码主要是和缓存路径相关的操作。

　　- (void)addReadOnlyCachePath:(nonnull NSString *)path {} 首先是添加自定义的缓存路径进 _customPaths 数组里面。SDWebImage 除了使用自己默认的 Library/Caches 路径，还能把自定义的路径指定为它默认的缓存路径或者其它的缓存路径。

- (nullable NSString *)cachedFileNameForKey:(nullable NSString *)key {
    const char *str = key.UTF8String;
    if (str == NULL) {
        str = "";
    }
    unsigned char r[CC_MD5_DIGEST_LENGTH];
    CC_MD5(str, (CC_LONG)strlen(str), r);
    NSString *filename = [NSString stringWithFormat:@"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%@",
                          r[0], r[1], r[2], r[3], r[4], r[5], r[6], r[7], r[8], r[9], r[10],
                          r[11], r[12], r[13], r[14], r[15], [key.pathExtension isEqualToString:@""] ? @"" : [NSString stringWithFormat:@".%@", key.pathExtension]];

    return filename;
}

　　主要先看一下这个方法的实现，这个方法的主要功能是根据图片的 URL 返回一个 MD5 处理的文件名。

这里的参数 key 多为图片的 URL，把图片的 URL 使用 MD5 方式转化，同时当 URL 有后缀的时候，做加点处理。

- (nullable NSString *)makeDiskCachePath:(nonnull NSString*)fullNamespace {
    NSArray<NSString *> *paths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES);
    return [paths[0] stringByAppendingPathComponent:fullNamespace];
}

　　这个方法主要是根据传进来的命名空间 fullNamespace （默认的命名空间 @"com.hackemist.SDWebImageCache.default"）拼接 Library/Caches 返回图片磁盘缓存的路径。

- (nullable NSString *)cachePathForKey:(nullable NSString *)key inPath:(nonnull NSString *)path {
    NSString *filename = [self cachedFileNameForKey:key];
    return [path stringByAppendingPathComponent:filename];
}

　　获取某个键的缓存路径（需要缓存路径根文件夹）。

　　根据传入的 key 获得文件名然后和缓存路径的根文件夹的路径 path（根据参数 path 传入，多为默认的缓存路径，或者自己创建并指定的缓存路径） 拼接，返回 key 指定的图像的完整路径。

- (nullable NSString *)defaultCachePathForKey:(nullable NSString *)key {
    return [self cachePathForKey:key inPath:self.diskCachePath];
}

　　获取某个键的默认的缓存路径。

　　缓存路径存在的情况:

　　1.使用  - (instancetype)init 方法初始化 SDImageCache 的时候：

　　Library/Caches / default / com.hackemist.SDWebImageCache.default

　　2.使用 - (nonnull instancetype)initWithNamespace:(nonnull NSString *)ns 初始化的时候:

　　Library/Caches / ns / com.hackemist.SDWebImageCache.ns

　　3.- (nonnull instancetype)initWithNamespace:(nonnull NSString *)ns diskCacheDirectory:(nonnull NSString *)directory 初始化的时候:

　　ns 不是空 directory 不是空的时候:

　　directory / com.hackemist.SDWebImageCache.ns

　　ns 不是空 directory 是空 的时候:

　　Library/Caches / ns

　　ns  是空 directory 不是空的时候:

　　directory / com.hackemist.SDWebImageCache

　　ns  是空 directory 是空的时候:

　　Library/Caches

　　Store Ops

#pragma mark - Store Ops

- (void)storeImage:(nullable UIImage *)image
            forKey:(nullable NSString *)key
        completion:(nullable SDWebImageNoParamsBlock)completionBlock {
    [self storeImage:image imageData:nil forKey:key toDisk:YES completion:completionBlock];
}

- (void)storeImage:(nullable UIImage *)image
            forKey:(nullable NSString *)key
            toDisk:(BOOL)toDisk
        completion:(nullable SDWebImageNoParamsBlock)completionBlock {
    [self storeImage:image imageData:nil forKey:key toDisk:toDisk completion:completionBlock];
}

- (void)storeImage:(nullable UIImage *)image
         imageData:(nullable NSData *)imageData
            forKey:(nullable NSString *)key
            toDisk:(BOOL)toDisk
        completion:(nullable SDWebImageNoParamsBlock)completionBlock {
    if (!image || !key) {
        if (completionBlock) {
            completionBlock();
        }
        return;
    }
    // if memory cache is enabled
    if (self.config.shouldCacheImagesInMemory) {
        NSUInteger cost = SDCacheCostForImage(image);
        [self.memCache setObject:image forKey:key cost:cost];
    }
    
    if (toDisk) {
        dispatch_async(self.ioQueue, ^{
            NSData *data = imageData;
            
            if (!data && image) {
                SDImageFormat imageFormatFromData = [NSData sd_imageFormatForImageData:data];
                data = [image sd_imageDataAsFormat:imageFormatFromData];
            }
            
            [self storeImageDataToDisk:data forKey:key];
            if (completionBlock) {
                dispatch_async(dispatch_get_main_queue(), ^{
                    completionBlock();
                });
            }
        });
    } else {
        if (completionBlock) {
            completionBlock();
        }
    }
}

- (void)storeImageDataToDisk:(nullable NSData *)imageData forKey:(nullable NSString *)key {
    if (!imageData || !key) {
        return;
    }
    
    [self checkIfQueueIsIOQueue];
    
    if (![_fileManager fileExistsAtPath:_diskCachePath]) {
        [_fileManager createDirectoryAtPath:_diskCachePath withIntermediateDirectories:YES attributes:nil error:NULL];
    }
    
    // get cache Path for image key
    NSString *cachePathForKey = [self defaultCachePathForKey:key];
    // transform to NSUrl
    NSURL *fileURL = [NSURL fileURLWithPath:cachePathForKey];
    
    [_fileManager createFileAtPath:cachePathForKey contents:imageData attributes:nil];
    
    // disable iCloud backup
    if (self.config.shouldDisableiCloud) {
        [fileURL setResourceValue:@YES forKey:NSURLIsExcludedFromBackupKey error:nil];
    }
}

　　这部分的函数主要用来存储图片的。

　　- (void)storeImage:(nullable UIImage *)image forKey:(nullable NSString *)key completion:(nullable SDWebImageNoParamsBlock)completionBlock {}

　　存储图片同时到磁盘缓存和内存缓存。

　　- (void)storeImage:(nullable UIImage *)image forKey:(nullable NSString *)key toDisk:(BOOL)toDisk completion:(nullable SDWebImageNoParamsBlock)completionBlock {}

　　加一个布尔类型的 toDisk，表示选择是否存入磁盘缓存。

　　上面的两个方法的实现都是调用:

- (void)storeImage:(nullable UIImage *)image imageData:(nullable NSData *)imageData forKey:(nullable NSString *)key toDisk:(BOOL)toDisk completion:(nullable SDWebImageNoParamsBlock)completionBlock {}

　　来完成的。

- (void)storeImage:(nullable UIImage *)image
         imageData:(nullable NSData *)imageData
            forKey:(nullable NSString *)key
            toDisk:(BOOL)toDisk
        completion:(nullable SDWebImageNoParamsBlock)completionBlock {
    if (!image || !key) {
        if (completionBlock) {
            completionBlock();
        }
        return;
    }
    // if memory cache is enabled
    if (self.config.shouldCacheImagesInMemory) {
        NSUInteger cost = SDCacheCostForImage(image);
        [self.memCache setObject:image forKey:key cost:cost];
    }
    
    if (toDisk) {
        dispatch_async(self.ioQueue, ^{
            NSData *data = imageData;
            
            if (!data && image) {
                SDImageFormat imageFormatFromData = [NSData sd_imageFormatForImageData:data];
                data = [image sd_imageDataAsFormat:imageFormatFromData];
            }
            
            [self storeImageDataToDisk:data forKey:key];
            if (completionBlock) {
                dispatch_async(dispatch_get_main_queue(), ^{
                    completionBlock();
                });
            }
        });
    } else {
        if (completionBlock) {
            completionBlock();
        }
    }
}

　　如果 image 不存在或者 key 不存在的时候，执行 completionBlock 并 return。

　　根据缓存配置类 _config 的 _shouldCacheImagesInMemory 属性，判断是否把图像存入内存中，

先计算出图像的占用内存，使用 _memCache 缓存图像到内存中。这个过程是非常快的，因此不用考虑线程。

　　如果 toDisk 为真，在串行队列 _ioQueue 中异步执行：

　　首先判断 data 和 image 两个参数，data 是 image 转化为的 NSData 数据。　

　　下面把 data 数据按处理过的文件名 key 保存在磁盘里面。（这里存入磁盘的数据是图像的 NSData 数据，不是 UIImage 图像，或者被压缩过的 UIImage 图像）

[self storeImageDataToDisk:data forKey:key];

　　这个方法的实现下面会详细讲述。

            if (completionBlock) {
                dispatch_async(dispatch_get_main_queue(), ^{
                    completionBlock();
                });
            }

　　当图像 data 数据存入磁盘完毕，如果 completionBlock 实现了，则在 _ioQueue 队列里面调取主线执行 completionBlock 。

　　下面如果 toDisk 不为真，则把 image 存入缓存以后，如果 completionBlock 实现了，则直接执行 completionBlock。

- (void)storeImageDataToDisk:(nullable NSData *)imageData forKey:(nullable NSString *)key {
    if (!imageData || !key) {
        return;
    }
    
    [self checkIfQueueIsIOQueue];
    
    if (![_fileManager fileExistsAtPath:_diskCachePath]) {
        [_fileManager createDirectoryAtPath:_diskCachePath withIntermediateDirectories:YES attributes:nil error:NULL];
    }
    
    // get cache Path for image key
    NSString *cachePathForKey = [self defaultCachePathForKey:key];
    // transform to NSUrl
    NSURL *fileURL = [NSURL fileURLWithPath:cachePathForKey];
    
    [_fileManager createFileAtPath:cachePathForKey contents:imageData attributes:nil];
    
    // disable iCloud backup
    if (self.config.shouldDisableiCloud) {
        [fileURL setResourceValue:@YES forKey:NSURLIsExcludedFromBackupKey error:nil];
    }
}

　　这个方法主要是实现把图像转化为 NSData 类型数据根据文件名 key 存入磁盘中。

　　首先如果 imageData 或者 key 不存在则直接返回。

　　然后检查当前是不是在 _ioQueue 队列里执行，这个方法只是一个打印处理提示处理。

　　使用文件管理类 _fileManager 判断 _diskCachePath 路径下是否有文件或者文件夹。

　　如果不存在则创建多级目录。

　　然后获得文件的完整路径 cachePathForkey。

　　根据完整的路径字符串转化为 NSURL。

　　使用文件管理类写文件到指定的路径中。把imageData 写入 cachePathForKey 路径下。

　　禁用 iCloud  备份。把文件的 URL 地址的 NSURLIsExcludedFromBackupKey 置为 YES。

　　Query and Retrieve Ops

　　这部分的代码很多，不贴出来了，只是把各个方法拆分一一的解析。 

- (void)diskImageExistsWithKey:(nullable NSString *)key completion:(nullable SDWebImageCheckCacheCompletionBlock)completionBlock {
    dispatch_async(_ioQueue, ^{
        BOOL exists = [_fileManager fileExistsAtPath:[self defaultCachePathForKey:key]];

        // fallback because of https://github.com/rs/SDWebImage/pull/976 that added the extension to the disk file name
        // checking the key with and without the extension
        if (!exists) {
            exists = [_fileManager fileExistsAtPath:[self defaultCachePathForKey:key].stringByDeletingPathExtension];
        }

        if (completionBlock) {
            dispatch_async(dispatch_get_main_queue(), ^{
                completionBlock(exists);
            });
        }
    });
}

　　这个方法看名字就很好理解，根据 key 检测默认的磁盘缓存路径中是否存在指定的图像。由于检测磁盘较慢，检测的结果并不是在函数的返回值里面返回，当检测完毕会执行检测完成的 completionBlock 回调，这个 block 只有一个布尔类型的参数，表示是否检测到指定图片。

　　在 _ioQueue 队列里面异步执行。

　　先根据 key 获得默认的完整的存储路径，检测文件是否存在。

　　如果不存在，则删除路径的末尾的扩展名再检测一遍。

　　然后调取主线程把检测结果 YES 或 NO 作为 block 参数执行 completionBlock 。

- (nullable UIImage *)imageFromMemoryCacheForKey:(nullable NSString *)key {
    return [self.memCache objectForKey:key];
}

　　根据 key 返回内存中存在的指定的图像。

- (nullable UIImage *)imageFromDiskCacheForKey:(nullable NSString *)key {
    UIImage *diskImage = [self diskImageForKey:key];
    if (diskImage && self.config.shouldCacheImagesInMemory) {
        NSUInteger cost = SDCacheCostForImage(diskImage);
        [self.memCache setObject:diskImage forKey:key cost:cost];
    }

    return diskImage;
}

　　根据 key 搜索全部磁盘缓存路径中存在的指定的图像。如果图像存在并且缓存配置类的 shouldCacheImagesInMemory 属性为 YES （表示使用内存缓存），则把得到的图像存入内存缓存中。返回获得的指定的图像。

- (nullable UIImage *)imageFromCacheForKey:(nullable NSString *)key {
    // First check the in-memory cache...
    UIImage *image = [self imageFromMemoryCacheForKey:key];
    if (image) {
        return image;
    }
    
    // Second check the disk cache...
    image = [self imageFromDiskCacheForKey:key];
    return image;
}

　　根据 key 获得缓存中指定的图片，首先检测内存缓存中是否有图像，如果有直接返回，如果没有，再去磁盘中检测图像是否存在，然后返回。

- (nullable NSData *)diskImageDataBySearchingAllPathsForKey:(nullable NSString *)key {
    NSString *defaultPath = [self defaultCachePathForKey:key];
    NSData *data = [NSData dataWithContentsOfFile:defaultPath];
    if (data) {
        return data;
    }

    // fallback because of https://github.com/rs/SDWebImage/pull/976 that added the extension to the disk file name
    // checking the key with and without the extension
    data = [NSData dataWithContentsOfFile:defaultPath.stringByDeletingPathExtension];
    if (data) {
        return data;
    }

    NSArray<NSString *> *customPaths = [self.customPaths copy];
    for (NSString *path in customPaths) {
        NSString *filePath = [self cachePathForKey:key inPath:path];
        NSData *imageData = [NSData dataWithContentsOfFile:filePath];
        if (imageData) {
            return imageData;
        }

        // fallback because of https://github.com/rs/SDWebImage/pull/976 that added the extension to the disk file name
        // checking the key with and without the extension
        imageData = [NSData dataWithContentsOfFile:filePath.stringByDeletingPathExtension];
        if (imageData) {
            return imageData;
        }
    }

    return nil;
}

　　根据 key 搜索全部的磁盘缓存路径，返回指定的图像的 NSData 数据。

　　首先从默认的缓存路径下读取 NSData 数据，如果有则直接返回 data。

　　如果不存在的时候删除默认路径的扩展名再读取一次，如果有则直接返回 data。

　　如果不存在的时候，便利存放自定义的缓存路径的数组 _customPaths，读取图像的 NSData 数据。每一次读取都是先从完整路径下面去读，读不到的时候再删除路径的扩展名去读数据。如果依然读不到则进入下次循环。

- (nullable UIImage *)diskImageForKey:(nullable NSString *)key {
    NSData *data = [self diskImageDataBySearchingAllPathsForKey:key];
    if (data) {
        UIImage *image = [UIImage sd_imageWithData:data];
        image = [self scaledImageForKey:key image:image];
        if (self.config.shouldDecompressImages) {
            image = [UIImage decodedImageWithImage:image];
        }
        return image;
    }
    else {
        return nil;
    }
}

　　首先搜索全部的缓存路径获得图像的 NSData 数据，如果数据存在则把 NSData 转化为 UIImage，根据 key 调整图像的大小（如果 key 里面有 @2x 或者 @3x 的时候，scale 是 2 或者 3），根据配置类的 _shouldDecompressImages 属性是否解压图像，最后返回图像。

- (nullable UIImage *)scaledImageForKey:(nullable NSString *)key image:(nullable UIImage *)image {
    return SDScaledImageForKey(key, image);
}

- (nullable NSOperation *)queryCacheOperationForKey:(nullable NSString *)key done:(nullable SDCacheQueryCompletedBlock)doneBlock {
    if (!key) {
        if (doneBlock) {
            doneBlock(nil, nil, SDImageCacheTypeNone);
        }
        return nil;
    }

    // First check the in-memory cache...
    UIImage *image = [self imageFromMemoryCacheForKey:key];
    if (image) {
        NSData *diskData = nil;
        if ([image isGIF]) {
            diskData = [self diskImageDataBySearchingAllPathsForKey:key];
        }
        if (doneBlock) {
            doneBlock(image, diskData, SDImageCacheTypeMemory);
        }
        return nil;
    }

    NSOperation *operation = [NSOperation new];
    dispatch_async(self.ioQueue, ^{
        if (operation.isCancelled) {
            // do not call the completion if cancelled
            return;
        }

        @autoreleasepool {
            NSData *diskData = [self diskImageDataBySearchingAllPathsForKey:key];
            UIImage *diskImage = [self diskImageForKey:key];
            if (diskImage && self.config.shouldCacheImagesInMemory) {
                NSUInteger cost = SDCacheCostForImage(diskImage);
                [self.memCache setObject:diskImage forKey:key cost:cost];
            }

            if (doneBlock) {
                dispatch_async(dispatch_get_main_queue(), ^{
                    doneBlock(diskImage, diskData, SDImageCacheTypeDisk);
                });
            }
        }
    });

    return operation;
}

　　这个根据 key 检测缓存的操作，返回值是一个 NSOperation 对象，方便后面的取消检测操作，主要磁盘缓存比较耗时，检测内存缓存比较快。当检测到图像的时候会执行一个 SDCacheQueryCompletedBlock 的 doneBlock。下面是这个 block 在 SDImageCache.h 里面的定义。

typedef NS_ENUM(NSInteger, SDImageCacheType) {
    /**
     * The image wasn't available the SDWebImage caches, but was downloaded from the web.
     */
    SDImageCacheTypeNone,
    /**
     * The image was obtained from the disk cache.
     */
    SDImageCacheTypeDisk,
    /**
     * The image was obtained from the memory cache.
     */
    SDImageCacheTypeMemory
};

typedef void(^SDCacheQueryCompletedBlock)(UIImage * _Nullable image, NSData * _Nullable data, SDImageCacheType cacheType);

　　如果 key 不存在，则直接执行 doneBlock，参数 image 是 nil data 是 nil 缓存类型 SDImageCacheType 是 SDImageCacheTypeNone。返回 nil。

　　如果 key 存在，首先检测内存缓存，如果有 image 图像，如果 image 是 GIF 图像，从磁盘读取 image 图像的 data 数据，执行 doneBlock ，返回 nil。

　　如果缓存路径中没有找到图像，则接下来到磁盘中去找图像。

　　在 _ioQueue 中异步执行，创建一个 NSOperation 类型的 operation，如果 operation 取消了则直接 return。

　　如果没有取消，在一个自动释放池里面，从全部的磁盘缓存路径中遍历，获得图像的 data 数据，和 UIImage 对象，如果 UIImage 存在且缓存配置类 _shouldCacheImagesInMemory 为真，即保存到内存缓存中，则把 UIImage 对象再保存到内存缓存中。然后执行 doneBlock。返回 operation。

　　Remove Ops

- (void)removeImageForKey:(nullable NSString *)key withCompletion:(nullable SDWebImageNoParamsBlock)completion {
    [self removeImageForKey:key fromDisk:YES withCompletion:completion];
}

- (void)removeImageForKey:(nullable NSString *)key fromDisk:(BOOL)fromDisk withCompletion:(nullable SDWebImageNoParamsBlock)completion {
    if (key == nil) {
        return;
    }

    if (self.config.shouldCacheImagesInMemory) {
        [self.memCache removeObjectForKey:key];
    }

    if (fromDisk) {
        dispatch_async(self.ioQueue, ^{
            [_fileManager removeItemAtPath:[self defaultCachePathForKey:key] error:nil];
            
            if (completion) {
                dispatch_async(dispatch_get_main_queue(), ^{
                    completion();
                });
            }
        });
    } else if (completion){
        completion();
    }
    
}

　　根据 key 删除指定的 image，如果 key 等于 nil，则直接返回。

　　首先判断缓存配置类的 _shouldCacheImagesInMemory 是否为YES，如果是 YES 则使用 _memCache 根据 key 删除缓存中的 image。

　　根据 fromDisk 判断是否删除磁盘缓存中的指定的 image。

　　如果 fromDisk 为真，在 _ioQueue 队列中异步删除默认路径下的指定的图像。删除完成调取主线执行完成的 block （一个没有参数没有返回值的 block）。

typedef void(^SDWebImageNoParamsBlock)();

　　Mem Cache settings

# pragma mark - Mem Cache settings

- (void)setMaxMemoryCost:(NSUInteger)maxMemoryCost {
    self.memCache.totalCostLimit = maxMemoryCost;
}

- (NSUInteger)maxMemoryCost {
    return self.memCache.totalCostLimit;
}

- (NSUInteger)maxMemoryCountLimit {
    return self.memCache.countLimit;
}

- (void)setMaxMemoryCountLimit:(NSUInteger)maxCountLimit {
    self.memCache.countLimit = maxCountLimit;
}

　　重写 _maxMemoryCost 的 set 和 get 方法。

　　_maxMemoryCost 的 set 方法设置 _memCache.totalCostLimit 内存缓存的最大容量。

　　_maxMemoryCost 的 get 方法直接返回 _memCache.totalCostLimit。

　　重写 _maxMemoryCountLimit 的 set 和 get 方法。

　　_maxMemoryCountLimit 的 set 方法设置 _memCache.countLimit 内存缓存的最大文件数量。

　　_maxMemoryCountLimit 的 get 方法直接返回  _maxCache.countLimit。

　　Cache clean Ops

　　清除数据。

- (void)clearMemory {
    [self.memCache removeAllObjects];
}

　　清空内存缓存的所有数据。

- (void)clearDiskOnCompletion:(nullable SDWebImageNoParamsBlock)completion {
    dispatch_async(self.ioQueue, ^{
        [_fileManager removeItemAtPath:self.diskCachePath error:nil];
        [_fileManager createDirectoryAtPath:self.diskCachePath
                withIntermediateDirectories:YES
                                 attributes:nil
                                      error:NULL];

        if (completion) {
            dispatch_async(dispatch_get_main_queue(), ^{
                completion();
            });
        }
    });
}

　　在 _ioQueue 队列异步删除 _diskCachePath 的所有数据，然后再创建 _diskCachePath  路径的文件夹。删除完毕调取主线执行 completion block。

- (void)deleteOldFiles {
    [self deleteOldFilesWithCompletionBlock:nil];
}

- (void)deleteOldFilesWithCompletionBlock:(nullable SDWebImageNoParamsBlock)completionBlock {
    dispatch_async(self.ioQueue, ^{
        NSURL *diskCacheURL = [NSURL fileURLWithPath:self.diskCachePath isDirectory:YES];
        NSArray<NSString *> *resourceKeys = @[NSURLIsDirectoryKey, NSURLContentModificationDateKey, NSURLTotalFileAllocatedSizeKey];

        // This enumerator prefetches useful properties for our cache files.
        NSDirectoryEnumerator *fileEnumerator = [_fileManager enumeratorAtURL:diskCacheURL
                                                   includingPropertiesForKeys:resourceKeys
                                                                      options:NSDirectoryEnumerationSkipsHiddenFiles
                                                                 errorHandler:NULL];

        NSDate *expirationDate = [NSDate dateWithTimeIntervalSinceNow:-self.config.maxCacheAge];
        NSMutableDictionary<NSURL *, NSDictionary<NSString *, id> *> *cacheFiles = [NSMutableDictionary dictionary];
        NSUInteger currentCacheSize = 0;

        // Enumerate all of the files in the cache directory.  This loop has two purposes:
        //
        //  1. Removing files that are older than the expiration date.
        //  2. Storing file attributes for the size-based cleanup pass.
        NSMutableArray<NSURL *> *urlsToDelete = [[NSMutableArray alloc] init];
        for (NSURL *fileURL in fileEnumerator) {
            NSError *error;
            NSDictionary<NSString *, id> *resourceValues = [fileURL resourceValuesForKeys:resourceKeys error:&error];

            // Skip directories and errors.
            if (error || !resourceValues || [resourceValues[NSURLIsDirectoryKey] boolValue]) {
                continue;
            }

            // Remove files that are older than the expiration date;
            NSDate *modificationDate = resourceValues[NSURLContentModificationDateKey];
            if ([[modificationDate laterDate:expirationDate] isEqualToDate:expirationDate]) {
                [urlsToDelete addObject:fileURL];
                continue;
            }

            // Store a reference to this file and account for its total size.
            NSNumber *totalAllocatedSize = resourceValues[NSURLTotalFileAllocatedSizeKey];
            currentCacheSize += totalAllocatedSize.unsignedIntegerValue;
            cacheFiles[fileURL] = resourceValues;
        }
        
        for (NSURL *fileURL in urlsToDelete) {
            [_fileManager removeItemAtURL:fileURL error:nil];
        }

        // If our remaining disk cache exceeds a configured maximum size, perform a second
        // size-based cleanup pass.  We delete the oldest files first.
        if (self.config.maxCacheSize > 0 && currentCacheSize > self.config.maxCacheSize) {
            // Target half of our maximum cache size for this cleanup pass.
            const NSUInteger desiredCacheSize = self.config.maxCacheSize / 2;

            // Sort the remaining cache files by their last modification time (oldest first).
            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 ([_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();
            });
        }
    });
}

　　清空旧的数据。

　　在 _ioQueue 队列里面异步执行。

　　 _diskCachePath  做参数返回它的 NSURL diskCacheURL，定义一个存放文件系统资源键的数组 resourceKeys 里面放了3个资源键 NSURLResourceKey:

        NSArray<NSString *> *resourceKeys = @[NSURLIsDirectoryKey, NSURLContentModificationDateKey, NSURLTotalFileAllocatedSizeKey];

　　NSURLIsDirectoryKey 是否是文件夹（只读，值为布尔类型）

　　NSURLContentModificationDateKey 资源的最后修改时间（可读可写，值为 NSDate 类型）

　　NSURLTotalFileAllocatedSizeKey 文件分配的内存大小（只读，值为 NSNumber 类型）

/* enumeratorAtURL:includingPropertiesForKeys:options:errorHandler: returns an NSDirectoryEnumerator rooted at the provided directory URL. The NSDirectoryEnumerator returns NSURLs from the -nextObject method. The optional 'includingPropertiesForKeys' parameter indicates which resource properties should be pre-fetched and cached with each enumerated URL. The optional 'errorHandler' block argument is invoked when an error occurs. Parameters to the block are the URL on which an error occurred and the error. When the error handler returns YES, enumeration continues if possible. Enumeration stops immediately when the error handler returns NO.

    If you wish to only receive the URLs and no other attributes, then pass '0' for 'options' and an empty NSArray ('[NSArray array]') for 'keys'. If you wish to have the property caches of the vended URLs pre-populated with a default set of attributes, then pass '0' for 'options' and 'nil' for 'keys'.
 */
- (nullable NSDirectoryEnumerator<NSURL *> *)enumeratorAtURL:(NSURL *)url includingPropertiesForKeys:(nullable NSArray<NSURLResourceKey> *)keys options:(NSDirectoryEnumerationOptions)mask errorHandler:(nullable BOOL (^)(NSURL *url, NSError *error))handler NS_AVAILABLE(10_6, 4_0);

 　　这个方法把 diskCacheURL\reslurceKeys 数组和一个 NSDirectoryEnumerationOptions 当参数传入，返回一个 NSDirectoryEnumerator<NSURL *> * 对象，这个对象里面存放的都是 NSURL。mask（过滤参数） 传入的是 NSDirectoryEnumerationSkipsHiddenFiles 是指忽略隐藏文件。

        NSDate *expirationDate = [NSDate dateWithTimeIntervalSinceNow:-self.config.maxCacheAge];

　　过期日期，默认的缓存的最大日期 _config.maxCacheAge 是一周，计算距离当前一周前的时间点 expirationDate。

        NSMutableDictionary<NSURL *, NSDictionary<NSString *, id> *> *cacheFiles = [NSMutableDictionary dictionary];
        NSUInteger currentCacheSize = 0;

　　定义一个可变字典 cacheFiles 和 一个NSUInteger 类型的 currentCacheSize。

　　cacheFiles 字典的 每一个 key 都是一个 NSURL ，每一个 key 对应的 value 是一个字典。这每一个 NSURL 对应的是 _diskCachePath 路径下每一个文件（包括文件夹或者图片文件）的路径的 URL，这个每一个 key 对应的字典是这每个 URL 下文件的不同的属性和属性值所组成的字典。

　　currentCacheSize 纪录的是 _diskCachePath 路径下，所有不过期的图片文件的总的占用的内存大小。

 

　　下面开始枚举缓存目录中的所有文件，这个循环有两个目的:

　　1.移除大于过期日期的文件。

　　2.存储基于大小的清除通道的文件属性。

NSMutableArray<NSURL *> *urlsToDelete = [[NSMutableArray alloc] init];

　　定义一个里面存放的都是 NSURL 的可变数组，用来存放下面 forIn 循环里面判断得出的需要删除的 NSURL。

　　下面开始使用 ForIn 遍历 fileEnumerator。

            NSError *error;
            NSDictionary<NSString *, id> *resourceValues = [fileURL resourceValuesForKeys:resourceKeys error:&error];

 　　对每一个 fileURL 取 resourceKeys 数组里面每一个 NSURLResourceKey 作为 key 时对应的 value 值，并把值放在 resourceValues 字典里面。

            // Skip directories and errors.
            if (error || !resourceValues || [resourceValues[NSURLIsDirectoryKey] boolValue]) {
                continue;
            }

　　当取 resourceValues 时有 error 和 当前的 fileURL 是文件夹的时候，跳出本次循环，进入下次循环。

            // Remove files that are older than the expiration date;
            NSDate *modificationDate = resourceValues[NSURLContentModificationDateKey];
            if ([[modificationDate laterDate:expirationDate] isEqualToDate:expirationDate]) {
                [urlsToDelete addObject:fileURL];
                continue;
            }

　　从 resourceValues 里面取出 NSURLContentModificationDateKey 的值，即当前文件的最后修改的时间的 NSDate 的值并把该值赋给 modificationDate 。

　　比较 modificationDate 和 expirationDate 两个时间点谁是较晚的时间点，如果是 expirationDate，即表示当前循环的这个 URL 下的文件的最后修改时间是在当前时间点一周之前的时间点的，那当前循环的这个 URL 下面的文件是需要删除的，把当前的这个 URL 加入到 urlsToDelete 数组里面，跳出本次循环，进入下次循环。

            // Store a reference to this file and account for its total size.
            NSNumber *totalAllocatedSize = resourceValues[NSURLTotalFileAllocatedSizeKey];
            currentCacheSize += totalAllocatedSize.unsignedIntegerValue;
            cacheFiles[fileURL] = resourceValues;

　　如果当前循环的 URL 下是文件，且没有超出缓存限制时间，则首先通过 resourceValues 字典的 NSURLTotalFileAllocatedSizeKey 的 value 值获得当前文件所占内存的大小 totalAllocatedSize。 把 totalAllocatedSize 的值转化为无符号 Integer 的值和循环开始时定义的纪录当前没有过期的图片总的缓存容量的 NSUInterger 类型的 currentCacheSize 变量作加法运算并把结果赋给 currentCacheSize。

　　并把当前循环下的不过期的图片文件的路径的 URL 作 key，对应的每个 URL 下文件的不同的属性和属性值所组成的字典作 value，添加到 cacheFiles 这个可变字典里面。

        for (NSURL *fileURL in urlsToDelete) {
            [_fileManager removeItemAtURL:fileURL error:nil];
        }

　　当上一个循环结束，对上个循环的里面纪录需要删除的图片文件的 URL 的 urlsToDelete 数组进行遍历，删除每一个 URL 下的文件。

        // If our remaining disk cache exceeds a configured maximum size, perform a second
        // size-based cleanup pass.  We delete the oldest files first.
        if (self.config.maxCacheSize > 0 && currentCacheSize > self.config.maxCacheSize) {
            // Target half of our maximum cache size for this cleanup pass.
            const NSUInteger desiredCacheSize = self.config.maxCacheSize / 2;

            // Sort the remaining cache files by their last modification time (oldest first).
            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 ([_fileManager removeItemAtURL:fileURL error:nil]) {
                    NSDictionary<NSString *, id> *resourceValues = cacheFiles[fileURL];
                    NSNumber *totalAllocatedSize = resourceValues[NSURLTotalFileAllocatedSizeKey];
                    currentCacheSize -= totalAllocatedSize.unsignedIntegerValue;

                    if (currentCacheSize < desiredCacheSize) {
                        break;
                    }
                }
            }
        }

　　如果删除完过期文件后，剩下的文件缓存还是超出了缓存类配置的缓存空间的大小，则接下来执行第二个清除方案，基于大小的清除方案。首先删除时间最老的文件。

　　如果缓存配置类配置的最大缓存空间 _maxCacheSize 的大小大于 0 并且当前的所有的不过期的缓存文件的大小总和大于缓存配置类配置的最大的缓存空间。

            // Target half of our maximum cache size for this cleanup pass.
            const NSUInteger desiredCacheSize = self.config.maxCacheSize / 2;

　　定义一个 NSUInteger 类型的变量 desiredCacheSize，值为当前缓存配置类的 _maxCacheSize 的一半。

            // Sort the remaining cache files by their last modification time (oldest first).
            NSArray<NSURL *> *sortedFiles = [cacheFiles keysSortedByValueWithOptions:NSSortConcurrent
                                                                     usingComparator:^NSComparisonResult(id obj1, id obj2) {
                                                                         return [obj1[NSURLContentModificationDateKey] compare:obj2[NSURLContentModificationDateKey]];
                                                                     }];

　　把当前的这些不过期的缓存文件，按上次的修改时间排序。最早的文件放在第一位。

- (NSArray<KeyType> *)keysSortedByValueWithOptions:(NSSortOptions)opts usingComparator:(NSComparator NS_NOESCAPE)cmptr NS_AVAILABLE(10_6, 4_0);

　　这个函数方法是一个对字典进行排序，这个方法会返回拍好序的字典的所有 key。NSSortOptions 是排序设置：

typedef NS_OPTIONS(NSUInteger, NSSortOptions) {
    NSSortConcurrent = (1UL << 0),
    NSSortStable = (1UL << 4),
};

　　NSSortConcurrent 是并发排序，效率高，但可能不稳定，NSSortStable 是稳定排序，但可能效率不如 NSSortConcurrent 高。排序的规则通过 cmptr block 的实现确定:

typedef NS_ENUM(NSInteger, NSComparisonResult) {NSOrderedAscending = -1L, NSOrderedSame, NSOrderedDescending};

　　该 block 返回值是一个 NSComparisonResult，取字典里的每一个 value 值的字典的 NSURLContentModificationDateKey 作比较。

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

                    if (currentCacheSize < desiredCacheSize) {
                        break;
                    }
                }
            }

　　拍完序后开始删除文件，每删除一个文件就把 currentCacheSize 减去删除文件的占用内存的大小。直到 currentCacheSize 的大小小于 desiredCacheSize 跳出循环。

　　如果 completionBlock 实现了，则调取主线程执行 completionBlock。

　　backgroundDeleteOldFiles

#if SD_UIKIT
- (void)backgroundDeleteOldFiles {
    Class UIApplicationClass = NSClassFromString(@"UIApplication");
    if(!UIApplicationClass || ![UIApplicationClass respondsToSelector:@selector(sharedApplication)]) {
        return;
    }
    UIApplication *application = [UIApplication performSelector:@selector(sharedApplication)];
    __block UIBackgroundTaskIdentifier bgTask = [application beginBackgroundTaskWithExpirationHandler:^{
        // Clean up any unfinished task business by marking where you
        // stopped or ending the task outright.
        [application endBackgroundTask:bgTask];
        bgTask = UIBackgroundTaskInvalid;
    }];

    // Start the long-running task and return immediately.
    [self deleteOldFilesWithCompletionBlock:^{
        [application endBackgroundTask:bgTask];
        bgTask = UIBackgroundTaskInvalid;
    }];
}
#endif

　　申请一段时间在后台删除旧数据

　　Cache Info 

#pragma mark - Cache Info

- (NSUInteger)getSize {
    __block NSUInteger size = 0;
    dispatch_sync(self.ioQueue, ^{
        NSDirectoryEnumerator *fileEnumerator = [_fileManager enumeratorAtPath:self.diskCachePath];
        for (NSString *fileName in fileEnumerator) {
            NSString *filePath = [self.diskCachePath stringByAppendingPathComponent:fileName];
            NSDictionary<NSString *, id> *attrs = [[NSFileManager defaultManager] attributesOfItemAtPath:filePath error:nil];
            size += [attrs fileSize];
        }
    });
    return size;
}

　　在 _ioQueue 队列里面异步计算 _diskCachePath 路径下所有的缓存文件的大小。

/* enumeratorAtPath: returns an NSDirectoryEnumerator rooted at the provided path. If the enumerator cannot be created, this returns NULL. Because NSDirectoryEnumerator is a subclass of NSEnumerator, the returned object can be used in the for...in construct.
 */
- (nullable NSDirectoryEnumerator<NSString *> *)enumeratorAtPath:(NSString *)path;

　　这个方法返回的 fileEnumerator 里面存放的是 _diskCachePath 路径下所有的文件的名字。

　　遍历 fileEnumerator，使用 NSFileManager 计算出所有文件的大小，返回 size。

- (NSUInteger)getDiskCount {
    __block NSUInteger count = 0;
    dispatch_sync(self.ioQueue, ^{
        NSDirectoryEnumerator *fileEnumerator = [_fileManager enumeratorAtPath:self.diskCachePath];
        count = fileEnumerator.allObjects.count;
    });
    return count;
}

　　返回所有文件的数量。

- (void)calculateSizeWithCompletionBlock:(nullable SDWebImageCalculateSizeBlock)completionBlock {
    NSURL *diskCacheURL = [NSURL fileURLWithPath:self.diskCachePath isDirectory:YES];

    dispatch_async(self.ioQueue, ^{
        NSUInteger fileCount = 0;
        NSUInteger totalSize = 0;

        NSDirectoryEnumerator *fileEnumerator = [_fileManager enumeratorAtURL:diskCacheURL
                                                   includingPropertiesForKeys:@[NSFileSize]
                                                                      options:NSDirectoryEnumerationSkipsHiddenFiles
                                                                 errorHandler:NULL];

        for (NSURL *fileURL in fileEnumerator) {
            NSNumber *fileSize;
            [fileURL getResourceValue:&fileSize forKey:NSURLFileSizeKey error:NULL];
            totalSize += fileSize.unsignedIntegerValue;
            fileCount += 1;
        }

        if (completionBlock) {
            dispatch_async(dispatch_get_main_queue(), ^{
                completionBlock(fileCount, totalSize);
            });
        }
    });
}

 　　　计算文件大小和文件数量，结果在 block 里面返回。

        NSDirectoryEnumerator *fileEnumerator = [_fileManager enumeratorAtURL:diskCacheURL
                                                   includingPropertiesForKeys:@[NSFileSize]
                                                                      options:NSDirectoryEnumerationSkipsHiddenFiles
                                                                 errorHandler:NULL];

　　在 _ioQueue 队列里面异步执行操作。

　　这里的参数  (nullable NSArray<NSURLResourceKey> *)keys 里面只有一个 FOUNDATION_EXPORT NSFileAttributeKey const NSFileSize; 用于获得文件大小。

　　如果 completionBlock 实现了，调取主线程在 执行该 block，block 两个参数一个纪录文件总个数，一个纪录文件的占用内存总大小。

typedef void(^SDWebImageCalculateSizeBlock)(NSUInteger fileCount, NSUInteger totalSize);

 

END 

 

参考链接:http://www.jianshu.com/p/a33d5abf686b

http://www.jianshu.com/p/5e69e211b161

http://www.jianshu.com/p/8ad9ff204f73

http://blog.csdn.net/songchunmin_/article/details/51103677