[iOS源码笔记]·第三方网络图片处理框架:SDWebImage网络下载及缓存管理策略

陈满iOS

发布于 2018-09-10 11:11:14

2K0

发布于 2018-09-10 11:11:14

文章被收录于专栏：陈满iOS陈满iOS

目前，虽然AFNetworking也提供了图片下载及缓存策略，但更专业的时候，图片加载框架一般用SDWebImage，正如主流APP(如QQ和微信)会用到。这里介绍一个查询主流APP主要框架的网站:AppSight。

官方Demo演示效果

1.框架简介

1.1 使用入门

Objective-C:

#import <SDWebImage/UIImageView+WebCache.h>
...
[imageView sd_setImageWithURL:[NSURL URLWithString:@"http://www.domain.com/path/to/image.jpg"]
             placeholderImage:[UIImage imageNamed:@"placeholder.png"]];

Swift:

import SDWebImage

imageView.sd_setImage(with: URL(string: "http://www.domain.com/path/to/image.jpg"), placeholderImage: UIImage(named: "placeholder.png"))

1.2 官方文档

这里提供一个笔者翻译的官方文档翻译版：
- [iOS学习笔记]·第三方网络图片处理框架:SDWebImage（官方文档翻译篇）

2.官方Demo调用实例解析

调用主体：

MasterViewController.m

导入文件：

#import <SDWebImage/UIImageView+WebCache.h>

调用方法：

...}

- 调用实例:

(UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath { static NSString *CellIdentifier = @"Cell"; static UIImage *placeholderImage = nil; if (!placeholderImage) { placeholderImage = UIImage imageNamed:@"placeholder"; } MyCustomTableViewCell *cell = tableView dequeueReusableCellWithIdentifier:CellIdentifier; if (cell == nil) { cell = [MyCustomTableViewCell alloc initWithStyle:UITableViewCellStyleDefault reuseIdentifier:CellIdentifier]; } cell.customImageView sd_setShowActivityIndicatorView:YES; cell.customImageView sd_setIndicatorStyle:UIActivityIndicatorViewStyleGray; cell.customTextLabel.text = NSString stringWithFormat:@"Image #%ld", (long)indexPath.row; [cell.customImageView sd_setImageWithURL:[NSURL URLWithString:_objectsindexPath.row] placeholderImage:placeholderImage options:indexPath.row == 0 ? SDWebImageRefreshCached : 0]; return cell; }

## 3.SDWebImage框架调用栈

- 框架体系

![框架体系](http://upload-images.jianshu.io/upload_images/1283539-048d262fac5403a7.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

- 方法调用栈

![方法调用栈](http://upload-images.jianshu.io/upload_images/1283539-576675a2a13bf4c9.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)


#### 3.1 第一层
- 类 

> **FLAnimatedImageView+WebCache.m**

- 方法

> ```- (void)sd_setImageWithURL:(nullable NSURL *)url placeholderImage:(nullable UIImage *)placeholder options:(SDWebImageOptions)options {
...}

实现

- (void)sd_setImageWithURL:(nullable NSURL *)url placeholderImage:(nullable UIImage *)placeholder options:(SDWebImageOptions)options {
    [self sd_setImageWithURL:url placeholderImage:placeholder options:options progress:nil completed:nil];
}

3.2 第二层

FLAnimatedImageView+WebCache.m

方法：

      placeholderImage:(nullable UIImage *)placeholder
               options:(SDWebImageOptions)options
              progress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
             completed:(nullable SDExternalCompletionBlock)completedBlock {

...}

- 作用：

> - 根据回调图设置自己的image属性
- 调用下一栈层，获取回调图

- 实现：

(void)sd_setImageWithURL:(nullable NSURL *)url placeholderImage:(nullable UIImage *)placeholder options:(SDWebImageOptions)options progress:(nullable SDWebImageDownloaderProgressBlock)progressBlock completed:(nullable SDExternalCompletionBlock)completedBlock { __weak typeof(self)weakSelf = self; [self sd_internalSetImageWithURL:url placeholderImage:placeholder options:options operationKey:nil setImageBlock:^(UIImage *image, NSData *imageData) { SDImageFormat imageFormat = NSData sd_imageFormatForImageData:imageData; if (imageFormat == SDImageFormatGIF) { weakSelf.animatedImage = FLAnimatedImage animatedImageWithGIFData:imageData; weakSelf.image = nil; } else { weakSelf.image = image; weakSelf.animatedImage = nil; } } progress:progressBlock completed:completedBlock];

}

其中:

typedef void(^SDExternalCompletionBlock)(UIImage * _Nullable image, NSError * _Nullable error, SDImageCacheType cacheType, NSURL * _Nullable imageURL);

#### 3.3 第三层 

- 类：

> **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 {
...}

作用：

判断条件用占位图返回给上一栈层
调用下一栈层，根据Url加载图片
实现：

- (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 {
    
    NSString *validOperationKey = operationKey ?: NSStringFromClass([self class]);
    [self sd_cancelImageLoadOperationWithKey:validOperationKey];
    objc_setAssociatedObject(self, &imageURLKey, url, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    
    if (!(options & SDWebImageDelayPlaceholder)) {
        dispatch_main_async_safe(^{
            [self sd_setImage:placeholder imageData:nil basedOnClassOrViaCustomSetImageBlock:setImageBlock];
        });
    }
    
    if (url) {
        // check if activityView is enabled or not
        if ([self sd_showActivityIndicatorView]) {
            [self sd_addActivityIndicator];
        }
        
        __weak __typeof(self)wself = self;
        id <SDWebImageOperation> operation = [SDWebImageManager.sharedManager loadImageWithURL:url options:options progress:progressBlock completed:^(UIImage *image, NSData *data, NSError *error, SDImageCacheType cacheType, BOOL finished, NSURL *imageURL) {
            __strong __typeof (wself) sself = wself;
            [sself sd_removeActivityIndicator];
            if (!sself) {
                return;
            }
            dispatch_main_async_safe(^{
                if (!sself) {
                    return;
                }
                if (image && (options & SDWebImageAvoidAutoSetImage) && completedBlock) {
                    completedBlock(image, error, cacheType, url);
                    return;
                } else if (image) {
                    [sself sd_setImage:image imageData:data basedOnClassOrViaCustomSetImageBlock:setImageBlock];
                    [sself sd_setNeedsLayout];
                } else {
                    if ((options & SDWebImageDelayPlaceholder)) {
                        [sself sd_setImage:placeholder imageData:nil basedOnClassOrViaCustomSetImageBlock:setImageBlock];
                        [sself sd_setNeedsLayout];
                    }
                }
                if (completedBlock && finished) {
                    completedBlock(image, error, cacheType, url);
                }
            });
        }];
        [self sd_setImageLoadOperation:operation forKey:validOperationKey];
    } else {
        dispatch_main_async_safe(^{
            [self sd_removeActivityIndicator];
            if (completedBlock) {
                NSError *error = [NSError errorWithDomain:SDWebImageErrorDomain code:-1 userInfo:@{NSLocalizedDescriptionKey : @"Trying to load a nil url"}];
                completedBlock(nil, error, SDImageCacheTypeNone, url);
            }
        });
    }
}

3.4 第四层

类名

SDWebImageManager.m

方法

                                 options:(SDWebImageOptions)options
                                progress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
                               completed:(nullable SDInternalCompletionBlock)completedBlock {

...}

- 作用

 - 缓存策略利用

 > 执行完缓存策略后，回调获取缓存图片数据:
如满足条件(`cachedImage && options & SDWebImageRefreshCached`)，则向上一栈层返回缓存图片。
```[self callCompletionBlockForOperation:weakOperation completion:completedBlock image:cachedImage data:cachedData error:nil cacheType:cacheType finished:YES url:url];

- 下载策略利用

>  执行完下载策略后，回调下载图片:
>  如有需要(`SDWebImageTransformAnimatedImage`)，转换格式后，保存到缓存
>  

```javascript

self.imageCache storeImage:transformedImage imageData:(imageWasTransformed ? nil : downloadedData) forKey:key toDisk:cacheOnDisk completion:nil;

如无必要，则直接保存到缓存

```javascript

self.imageCache storeImage:downloadedImage imageData:downloadedData forKey:key toDisk:cacheOnDisk completion:nil;

- 实现

```javascript

(id <SDWebImageOperation>)loadImageWithURL:(nullable NSURL *)url options:(SDWebImageOptions)options progress:(nullable SDWebImageDownloaderProgressBlock)progressBlock completed:(nullable SDInternalCompletionBlock)completedBlock { // Invoking this method without a completedBlock is pointless NSAssert(completedBlock != nil, @"If you mean to prefetch the image, use -SDWebImagePrefetcher prefetchURLs instead");

// Very common mistake is to send the URL using NSString object instead of NSURL. For some strange reason, Xcode won't

// throw any warning for this type mismatch. Here we failsafe this error by allowing URLs to be passed as NSString.

if ([url isKindOfClass:NSString.class]) {

    url = [NSURL URLWithString:(NSString *)url];

// Prevents app crashing on argument type error like sending NSNull instead of NSURL

if (![url isKindOfClass:NSURL.class]) {

    url = nil;

__block SDWebImageCombinedOperation *operation = [SDWebImageCombinedOperation new];

__weak SDWebImageCombinedOperation *weakOperation = operation;

BOOL isFailedUrl = NO;

if (url) {

    @synchronized (self.failedURLs) {

        isFailedUrl = [self.failedURLs containsObject:url];

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;

@synchronized (self.runningOperations) {

    [self.runningOperations addObject:operation];

NSString *key = [self cacheKeyForURL:url];

//缓存策略

operation.cacheOperation = [self.imageCache queryCacheOperationForKey:key done:^(UIImage *cachedImage, NSData *cachedData, SDImageCacheType cacheType) {

    if (operation.isCancelled) {

        [self safelyRemoveOperationFromRunning:operation];

        return;

    if ((!cachedImage || options & SDWebImageRefreshCached) && (![self.delegate respondsToSelector:@selector(imageManager:shouldDownloadImageForURL:)] || [self.delegate imageManager:self shouldDownloadImageForURL:url])) {

        if (cachedImage && options & SDWebImageRefreshCached) {

            // If image was found in the cache but SDWebImageRefreshCached is provided, notify about the cached image

            // AND try to re-download it in order to let a chance to NSURLCache to refresh it from server.

            [self callCompletionBlockForOperation:weakOperation completion:completedBlock image:cachedImage data:cachedData error:nil cacheType:cacheType finished:YES url:url];

        // download if no image or requested to refresh anyway, and download allowed by delegate

        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) {

            // force progressive off if image already cached but forced refreshing

            downloaderOptions &= ~SDWebImageDownloaderProgressiveDownload;

            // ignore image read from NSURLCache if image if cached but force refreshing

            downloaderOptions |= SDWebImageDownloaderIgnoreCachedResponse;

        //下载策略

        SDWebImageDownloadToken *subOperationToken = [self.imageDownloader downloadImageWithURL:url options:downloaderOptions progress:progressBlock completed:^(UIImage *downloadedImage, NSData *downloadedData, NSError *error, BOOL finished) {

            __strong __typeof(weakOperation) strongOperation = weakOperation;

            if (!strongOperation || strongOperation.isCancelled) {

                // Do nothing if the operation was cancelled

                // See #699 for more details

                // if we would call the completedBlock, there could be a race condition between this block and another completedBlock for the same object, so if this one is called second, we will overwrite the new data

            } else if (error) {

                [self callCompletionBlockForOperation:strongOperation completion:completedBlock error:error url:url];

                if (   error.code != NSURLErrorNotConnectedToInternet

                    && error.code != NSURLErrorCancelled

                    && error.code != NSURLErrorTimedOut

                    && error.code != NSURLErrorInternationalRoamingOff

                    && error.code != NSURLErrorDataNotAllowed

                    && error.code != NSURLErrorCannotFindHost

                    && error.code != NSURLErrorCannotConnectToHost

                    && error.code != NSURLErrorNetworkConnectionLost) {

                    @synchronized (self.failedURLs) {

                        [self.failedURLs addObject:url];

            else {

                if ((options & SDWebImageRetryFailed)) {

                    @synchronized (self.failedURLs) {

                        [self.failedURLs removeObject:url];

                BOOL cacheOnDisk = !(options & SDWebImageCacheMemoryOnly);

                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];

                            // pass nil if the image was transformed, so we can recalculate the data from the image

                            [self.imageCache storeImage:transformedImage imageData:(imageWasTransformed ? nil : downloadedData) forKey:key toDisk:cacheOnDisk completion:nil];

                        [self callCompletionBlockForOperation:strongOperation completion:completedBlock image:transformedImage data:downloadedData error:nil cacheType:SDImageCacheTypeNone finished:finished url:url];

});

                } else {

                    if (downloadedImage && finished) {

                        [self.imageCache storeImage:downloadedImage imageData:downloadedData forKey:key toDisk:cacheOnDisk completion:nil];

                    [self callCompletionBlockForOperation:strongOperation completion:completedBlock image:downloadedImage data:downloadedData error:nil cacheType:SDImageCacheTypeNone finished:finished url:url];

            if (finished) {

                [self safelyRemoveOperationFromRunning:strongOperation];

}];

        operation.cancelBlock = ^{

            [self.imageDownloader cancel:subOperationToken];

            __strong __typeof(weakOperation) strongOperation = weakOperation;

            [self safelyRemoveOperationFromRunning:strongOperation];

};

    } else if (cachedImage) {

        __strong __typeof(weakOperation) strongOperation = weakOperation;

        [self callCompletionBlockForOperation:strongOperation completion:completedBlock image:cachedImage data:cachedData error:nil cacheType:cacheType finished:YES url:url];

        [self safelyRemoveOperationFromRunning:operation];

    } else {

        // Image not in cache and download disallowed by delegate

        __strong __typeof(weakOperation) strongOperation = weakOperation;

        [self callCompletionBlockForOperation:strongOperation completion:completedBlock image:nil data:nil error:nil cacheType:SDImageCacheTypeNone finished:YES url:url];

        [self safelyRemoveOperationFromRunning:operation];

}];

return operation;

}

- 其中，缓存策略调用为

```javascript

//缓存策略

operation.cacheOperation = [self.imageCache queryCacheOperationForKey:key done:^(UIImage cachedImage, NSData cachedData, SDImageCacheType cacheType) {

...}

- 下载策略调用为

```javascript

//下载策略

SDWebImageDownloadToken subOperationToken = [self.imageDownloader downloadImageWithURL:url options:downloaderOptions progress:progressBlock completed:^(UIImage downloadedImage, NSData downloadedData, NSError error, BOOL finished) {

...}

## 4.缓存查询策略

- 类名

>  **SDImageCache.m**
>  

- 方法

>   
>  

...}

```javascript

作用

1) 先查询 Memory Cache

UIImage *image = [self imageFromMemoryCacheForKey:key];

2) 如果 Memory Cache 查找不到，就会查询 Disk Cache

`NSData diskData = self diskImageDataBySearchingAllPathsForKey:key; UIImage diskImage = self diskImageForKey:key;

3) 如果 Disk Cache 查询成功，还会把得到的图片再次设置到 Memory Cache 中。

[self.memCache setObject:diskImage forKey:key cost:cost];

4) 向block返回图片数据，如doneBlock(image, diskData, SDImageCacheTypeMemory);。

其中，关于image，所有图均需返回 UIImage *image = [self imageFromMemoryCacheForKey:key];。
关于diskData，如果为GIF图，需返回 diskData = [self diskImageDataBySearchingAllPathsForKey:key];，如果为非GIF图，则返回nil。

实现- (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; } ```javascript ## 5.下载管理策略
类名

SDWebImageDownloader.h

方法

                                               options:(SDWebImageDownloaderOptions)options

                                              progress:(nullable SDWebImageDownloaderProgressBlock)progressBlock

                                             completed:(nullable SDWebImageDownloaderCompletedBlock)completedBlock {

...}

- 作用
- 利用Url建立Request

```javascript

NSMutableURLRequest *request = [NSMutableURLRequest alloc initWithURL:url cachePolicy:cachePolicy timeoutInterval:timeoutInterval];

- 利用Request初始化SDWebImageDownloaderOperation下载对象

```javascript

SDWebImageDownloaderOperation *operation = [sself.operationClass alloc initWithRequest:request inSession:sself.session options:options];

- 实现

```javascript

(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;

    if (timeoutInterval == 0.0) {

        timeoutInterval = 15.0;

    // In order to prevent from potential duplicate caching (NSURLCache + SDImageCache) we disable the cache for image requests if told otherwise

    NSURLRequestCachePolicy cachePolicy = NSURLRequestReloadIgnoringLocalCacheData;

    if (options & SDWebImageDownloaderUseNSURLCache) {

        if (options & SDWebImageDownloaderIgnoreCachedResponse) {

            cachePolicy = NSURLRequestReturnCacheDataDontLoad;

        } else {

            cachePolicy = NSURLRequestUseProtocolCachePolicy;

    NSMutableURLRequest *request = [[NSMutableURLRequest alloc] initWithURL:url cachePolicy:cachePolicy timeoutInterval:timeoutInterval];

    request.HTTPShouldHandleCookies = (options & SDWebImageDownloaderHandleCookies);

    request.HTTPShouldUsePipelining = YES;

    if (sself.headersFilter) {

        request.allHTTPHeaderFields = sself.headersFilter(url, [sself.HTTPHeaders copy]);

    else {

        request.allHTTPHeaderFields = sself.HTTPHeaders;

    SDWebImageDownloaderOperation *operation = [[sself.operationClass alloc] initWithRequest:request inSession:sself.session options:options];

    operation.shouldDecompressImages = sself.shouldDecompressImages;

    if (sself.urlCredential) {

        operation.credential = sself.urlCredential;

    } else if (sself.username && sself.password) {

        operation.credential = [NSURLCredential credentialWithUser:sself.username password:sself.password persistence:NSURLCredentialPersistenceForSession];

    if (options & SDWebImageDownloaderHighPriority) {

        operation.queuePriority = NSOperationQueuePriorityHigh;

    } else if (options & SDWebImageDownloaderLowPriority) {

        operation.queuePriority = NSOperationQueuePriorityLow;

    [sself.downloadQueue addOperation:operation];

    if (sself.executionOrder == SDWebImageDownloaderLIFOExecutionOrder) {

        // Emulate LIFO execution order by systematically adding new operations as last operation's dependency

        [sself.lastAddedOperation addDependency:operation];

        sself.lastAddedOperation = operation;

    return operation;

}];

}

## 6.缓存管理策略

## 6.1 自动化缓存管理

- 类名

>  SDImageCacheConfig.h
>  

- 属性

```javascript

/**

The maximum length of time to keep an image in the cache, in seconds */ @property (assign, nonatomic) NSInteger maxCacheAge;

/**

The maximum size of the cache, in bytes. */ @property (assign, nonatomic) NSUInteger maxCacheSize;- 类名 > SDImageCacheConfig.m > - 实现 ```javascript static const NSInteger kDefaultCacheMaxCacheAge = 60 * 60 * 24 * 7; // 1 week

@implementation SDImageCacheConfig

(instancetype)init { if (self = super init) { _shouldDecompressImages = YES; _shouldDisableiCloud = YES; _shouldCacheImagesInMemory = YES; _maxCacheAge = kDefaultCacheMaxCacheAge; _maxCacheSize = 0; } return self; }

@end

- 类名

>  SDImageCache.m
>  

- 添加通知

```javascript

#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

- 内存警告：清除所有内存

```javascript

(void)clearMemory { self.memCache removeAllObjects; }- 程序结束：删除老文件（缩减一半） ```javascript 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;

- 进入后台:清除一半缓存并结束后台任务

```javascript

#if SD_UIKIT

(void)backgroundDeleteOldFiles { Class UIApplicationClass = NSClassFromString(@"UIApplication"); if(!UIApplicationClass || undefined) { 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

#### 6.2 手动化内存管理

- 手动设置最大缓存空间

```javascript

//调用处获取单例进行设置

SDImageCache sharedImageCache.config.maxCacheSize = 1024 1024 50; // 50M

- 手动设置缓存清理周期

```javascript

//SDImageCacheConfig.m

static const NSInteger kDefaultCacheMaxCacheAge = 60 60 24 * 7; // 1 week

- 手动清除缓存

```javascript

(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();

});

});

}

小结

学习最好的方式，是自己研读里面的源码，当然限于篇幅，本篇文章介绍的重点是缓存策略，而对SDWebImage的网络管理部分一提而过。如果你愿意深入研究，你会发现更多层的调用栈和线程管理的操作。下载官方源码SDWebImage，你可以研究更多。

官方下载与说明

本文参与腾讯云自媒体分享计划，分享自作者个人站点/博客。

原始发表：2017.06.29 ，如有侵权请联系 cloudcommunity@tencent.com 删除

ios

缓存

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体分享计划，欢迎热爱写作的你一起参与！

ios

缓存