持久化学习系列2

PINCache

第二篇是关于最经典的KV缓存解决方案PINCache

客户端的存储

在正式讲解PINCache前，先来谈谈客户端什么时候需要做存储。

总所周知，现在的APP越来越依赖网络，在离开网络的情况下，绝大多数的APP都成了摆设。然而，优秀的APP已经有自己的一套设计，避免在无网或者弱网的情况下完全失去作用。例如微信这样的强网络要求的APP,在失去网络的情况依然能够浏览本地缓存的聊天信息和朋友圈记录。优秀的APP，应该根据自己的业务需求，选择合适的存储方案。对于一般体量的APP来说，利用KV形式的存储是最好不过的选择。

KV，即Key-Value形式的存储。通常客户端的信息是由后端给出的json解析的,使用Key-Value正是方便了这种格式。

PINCache

PINCache是脱胎于TMCache，解决了TMCache中的线程死锁问题。PINCache中依然设计了memoryCache和diskCache两种，分别解决了临时存储和长期持久化的问题。
在PINCache的github主页上，提出在iOS上如果没有特别的情况，尽可能使用diskCache，原因是每次iOS应用启动，都会造成memoryCache中的内容被清空。在下面，会对比下内存缓存和磁盘缓存的优缺点，以及PINCache是如何实现的，

文件结构

从图上可以看到，PINCache的实现并不复杂，除去PINCache本身实现对外的方法外，总共只有八个实现文件。

PINMemoryCache

PINMemoryCache为实现内存缓存的类。什么是内存缓存，我们可以理解为通过一个NSMutableDictionary来临时存储对象。实现一个内存缓存难度不大，通常需要完成以下几个事情：

  1. 选择合适的存储结构
  2. 选择和实现对应的读写方法
  3. 选择和实现淘汰方法
  4. 处理系统内存警告

了解了以上步骤，我们来看看PINMemoryCache是怎么解决上面的问题

  1. 选择NSMutableDictionary作为存储结构
  2. 采用NSMutableDictionary的读写方法
  3. 通过两个NSMutableDictionary分别记录date和cost,实现时间和内容的管理。
  4. 收到内存警告后，清空内存中所有的对象，清空缓存。

看上去不难？在笔者看来，实现内存缓存的难度主要是2，3点。在这里，PINMemoryCache主要考虑的是如何解决多线程安全的问题，以及缓存淘汰问题。

多线程安全

由于缓存的特殊性，读写必须考虑到多线程安全的问题。如果一个线程改变了缓存中的某个值，而别的线正好需要这个值，处理不好轻则造成数据出错，重则造成程序崩溃。

在PINMemoryCache中，使用了pthread_mutex_t来保证线程安全。

pthread_mutex_t为互斥锁，当锁上的时候，其他线程就无法访问被锁上的资源

使用pthread_mutex_t需要注意几点。

必须在dealloc方法中主动释放

1
2
3
4
5
6
7
8

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

    __unused int result = pthread_mutex_destroy(&_mutex);
    NSCAssert(result == 0, @"Failed to destroy lock in PINMemoryCache %p. Code: %d", (void *)self, result);
}

单独使用pthread_mutex_t容易造成死锁，同时也坑你造成效率不高，可以通过实现对应的递归锁来避免

1
2
3
4
5
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&lock, &attr);
pthread_mutexattr_destroy(&attr);

在完成锁的初始化后，就需要考虑什么时候要加锁解锁了

为了避免data race的情况，在这里，PINMemoryCache选择了对所有读写操作都进行加锁。同时，采用副本的形式避免读取的数据被篡改。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
- (__nullable id)objectForKey:(NSString *)key
{
    if (!key)
        return nil;
    
    NSDate *now = [[NSDate alloc] init];
    [self lock];
        id object = nil;
        // If the cache should behave like a TTL cache, then only fetch the object if there's a valid ageLimit and  the object is still alive
        if (!self->_ttlCache || self->_ageLimit <= 0 || fabs([[_dates objectForKey:key] timeIntervalSinceDate:now]) < self->_ageLimit) {
            object = _dictionary[key];
        }
    [self unlock];
        
    if (object) {
        [self lock];
            _dates[key] = now;
        [self unlock];
    }

    return object;
}


- (void)setObject:(id)object forKey:(NSString *)key withCost:(NSUInteger)cost
{
    if (!key || !object)
        return;
    
    [self lock];
        PINMemoryCacheObjectBlock willAddObjectBlock = _willAddObjectBlock;
        PINMemoryCacheObjectBlock didAddObjectBlock = _didAddObjectBlock;
        NSUInteger costLimit = _costLimit;
    [self unlock];
    
    if (willAddObjectBlock)
        willAddObjectBlock(self, key, object);
    
    [self lock];
        NSNumber* oldCost = _costs[key];
        if (oldCost)
            _totalCost -= [oldCost unsignedIntegerValue];

        _dictionary[key] = object;
        _dates[key] = [[NSDate alloc] init];
        _costs[key] = @(cost);
        
        _totalCost += cost;
    [self unlock];
    
    if (didAddObjectBlock)
        didAddObjectBlock(self, key, object);
    
    if (costLimit > 0)
        [self trimToCostByDate:costLimit];
}

通过这两个读写方法，我们发现，PINMemoryCache对任何涉及属性操作的地方都进行了锁操作，避免了data race的情况。

缓存淘汰

缓存淘汰，也就是第三点。如果保证缓存中数据有效性，保证缓存搞笑的利用是所有缓存应该考虑的问题。通常来讲，我们应该从缓存利用率上来着手，只保留常被使用的数据，淘汰长期不需要的数据。LRU就会常用的一种缓存淘汰算法。在这里，PINMemoryCache通过时间和空间来实现的LRU算法。

在上面贴出的读写中，读的时候，更新date中key对应的时间。在写的时候，记录或更新key对应时间。

当触发缓存删除操作的时候，优先删除占用空间大和使用时间靠前的的内容。

至此，PINMemoryCache的内容基本就分析完了。内存缓存的实现，只要考虑清楚上面列的四个内容，我认为就不难做到，剩下的就是实现细节和性能的考量了。

PINDiskCache

PINDiskCache实现的磁盘缓存。我们知道，磁盘的读取速度要远小于内存读取。大量的磁盘I/O会降低程序的运行效率。虽然如此，面对大体量的数据以及需要长期存储的数据，我们只能考虑存储在磁盘上。同时，由于iOS系统的特殊性，选择存储在磁盘上往往是我们的第一选择。

和memory cache不同，磁盘I/O需要考虑的问题要更多一点，除了上面再memory cache讲到的几点外，还需要考虑一下几点。

  1. 实现方式。磁盘存储一般分为三种：文件读写，数据库，mmap文件内存映射。PINDiskCache使用的是文件读写的方式
  2. 存储位置。iOS文件系统不同位置建议存储的内容不同。是放在cache文件夹中还是temp文件中取决于开发者对存储文件的态度。
  3. 文件系统的细节。避免和其他文件产生冲突，必须考虑拥有自身的标记。
  4. 数据序列化

看上去磁盘缓存的实现的确要难上很多问题，在内存缓存的基础上依然要考虑这么多问题。

PINDiskCache在这四个问题上，充分考虑了oc语言已经iOS已经MAC OS系统的特性。首先采用文件读写的方式，依然考虑了数据的特性。文件读写的方式非常适合用于存储数据规模小的情况，同时实现方便，性能稳定也是选择的原因之一。但是使用文件存储也有不小的弱点：方便扩展、没有元数据、难以实现较好的淘汰算法、数据统计缓慢。

2，3，4点将在下面实现细节中会讲到。

实现细节

线程安全

线程安全依然是绕不过去的一个坎，在PINDiskCache里，除了需要对付一般的data race，还需要处理磁盘I/O带来的问题。

在这里，PINDiskCache使用的是NSConditionLock条件锁。在代码中有如下定义：

1
2
3
4
typedef NS_ENUM(NSUInteger, PINDiskCacheCondition) {
    PINDiskCacheConditionNotReady = 0,
    PINDiskCacheConditionReady = 1,
};

可见，条件锁中并不涉及到具体的实例对象，而是一个常量来作为锁的条件。在这里，个人认为直接用递归锁差别也不是很大，不知道为何这里选择使用了条件锁。（或许有一天知道了会回来补。

在使用中，所有对成员变量操作的地方都进行的锁操作。(实际上有些地方是不需要用的)

读写

磁盘读写如果不注意极其容易造成死锁。

写：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
- (void)setObject:(id <NSCoding>)object forKey:(NSString *)key fileURL:(NSURL **)outFileURL
{
    if (!key || !object)
        return;
    
    #if TARGET_OS_IPHONE
      NSDataWritingOptions writeOptions = NSDataWritingAtomic | self.writingProtectionOption;
    #else
      NSDataWritingOptions writeOptions = NSDataWritingAtomic;
    #endif
  
    NSURL *fileURL = [self encodedFileURLForKey:key];
    
    [self lock];
        PINDiskCacheObjectBlock willAddObjectBlock = self->_willAddObjectBlock;
        if (willAddObjectBlock) {
            [self unlock];
                willAddObjectBlock(self, key, object);
            [self lock];
        }
    
        //We unlock here so that we're not locked while serializing.
        [self unlock];
            NSData *data = _serializer(object, key);
        [self lock];
    
        NSError *writeError = nil;
  
        BOOL written = [data writeToURL:fileURL options:writeOptions error:&writeError];
        PINDiskCacheError(writeError);
        
        if (written) {
            NSError *error = nil;
            NSDictionary *values = [fileURL resourceValuesForKeys:@[ NSURLContentModificationDateKey, NSURLTotalFileAllocatedSizeKey ] error:&error];
            PINDiskCacheError(error);
            
            NSNumber *diskFileSize = [values objectForKey:NSURLTotalFileAllocatedSizeKey];
            if (diskFileSize) {
                NSNumber *prevDiskFileSize = [self->_sizes objectForKey:key];
                if (prevDiskFileSize) {
                    self.byteCount = self->_byteCount - [prevDiskFileSize unsignedIntegerValue];
                }
                [self->_sizes setObject:diskFileSize forKey:key];
                self.byteCount = self->_byteCount + [diskFileSize unsignedIntegerValue]; // atomic
            }
            NSDate *date = [values objectForKey:NSURLContentModificationDateKey];
            if (date) {
                [self->_dates setObject:date forKey:key];
            }
            
            if (self->_byteLimit > 0 && self->_byteCount > self->_byteLimit)
                [self trimToSizeByDate:self->_byteLimit block:nil];
        } else {
            fileURL = nil;
        }
    
        PINDiskCacheObjectBlock didAddObjectBlock = self->_didAddObjectBlock;
        if (didAddObjectBlock) {
            [self unlock];
                didAddObjectBlock(self, key, object);
            [self lock];
        }
    [self unlock];
    
    if (outFileURL) {
        *outFileURL = fileURL;
    }
}

读：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
- (__nullable id <NSCoding>)objectForKey:(NSString *)key fileURL:(NSURL **)outFileURL
{
    NSDate *now = [[NSDate alloc] init];
    
    if (!key)
        return nil;
    
    id <NSCoding> object = nil;
    NSURL *fileURL = [self encodedFileURLForKey:key];
    
    [self lock];
        if (!self->_ttlCache || self->_ageLimit <= 0 || fabs([[_dates objectForKey:key] timeIntervalSinceDate:now]) < self->_ageLimit) {
            // If the cache should behave like a TTL cache, then only fetch the object if there's a valid ageLimit and  the object is still alive
            NSData *objectData = [[NSData alloc] initWithContentsOfFile:[fileURL path]];
          
            if (objectData) {
              //Be careful with locking below. We unlock here so that we're not locked while deserializing, we re-lock after.
              [self unlock];
              @try {
                  object = _deserializer(objectData, key);
              }
              @catch (NSException *exception) {
                  NSError *error = nil;
                  [self lock];
                      [[NSFileManager defaultManager] removeItemAtPath:[fileURL path] error:&error];
                  [self unlock];
                  PINDiskCacheError(error);
              }
              [self lock];
            }
            if (object && !self->_ttlCache) {
                [self asynchronouslySetFileModificationDate:now forURL:fileURL];
            }
        }
    [self unlock];
    
    if (outFileURL) {
        *outFileURL = fileURL;
    }
    
    return object;
}

在序列化和反序列化的地方解锁，之后再上锁，目的是避免死锁问题(序列化失败等)。

在读写之后，改变文件的最后修改时间，作为一个参考依据。

在写入的时候，先尝试将数据写入到磁盘，然后读取写入的文件的信息，比较文件的大小是否和写入的数据大小相同

异步操作

在PINDiskCache中大量使用了异步操作。比如读取文件后修改文件时间：

1
2
3
4
5
6
7
8
9
10
11
12
- (void)asynchronouslySetFileModificationDate:(NSDate *)date forURL:(NSURL *)fileURL
{
    __weak PINDiskCache *weakSelf = self;
    [self.operationQueue addOperation:^{
        PINDiskCache *strongSelf = weakSelf;
        if (strongSelf) {
            [strongSelf lock];
                [strongSelf _locked_setFileModificationDate:date forURL:fileURL];
            [strongSelf unlock];
        }
    } withPriority:PINOperationQueuePriorityLow];
}

这里用的operationQueue就是在下面要讲到PINCache自己实现的一套异步方案

淘汰方法

PINDiskCache仍然根据文件大小和最近修改时间来作为淘汰的依据。

PINOperationQueue

PINOperationQueue是PINCache实现的一个并发控制方案。实现了最大并发数，取消，优先级管理。在PINDiskCache中大量使用了PINOperationQueue来达到并发行为的控制。

实现细节

PINOperationQueue是对外公开的操作，主要是通过下面方法添加操作

1
2
3
4
5
6
- (id <PINOperationReference>)addOperation:(PINOperationBlock)operation
                              withPriority:(PINOperationQueuePriority)priority
                                identifier:(NSString *)identifier
                            coalescingData:(nullable id)coalescingData
                      dataCoallescingBlock:(nullable PINOperationDataCoallescingBlock)dataCoallescingBlock
                                completion:(nullable dispatch_block_t)completion;

其中dataCoallescingBlock和coalescingData提供了联合数据处理的能力，例如

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
- (void)trimToDate:(NSDate *)trimDate block:(PINDiskCacheBlock)block
{
    PINOperationBlock operation = ^(id data){
        [self trimToDate:(NSDate *)data];
    };
    
    dispatch_block_t completion = nil;
    if (block) {
        completion = ^{
            block(self);
        };
    }
    
    [self.operationQueue addOperation:operation
                         withPriority:PINOperationQueuePriorityLow
                           identifier:PINDiskCacheOperationIdentifierTrimToDate
                       coalescingData:trimDate
                  dataCoallescingBlock:PINDiskTrimmingDateCoallescingBlock
                           completion:completion];
}

这个方法中，DiskCache会去清除指定时间的数据，在这里，添加到PINOperationQueue的时候，将trimDate作为联合数据传入。这里的联合数据，可以认为是block之外的一个负载。

初始化

通过初始化可以得知，PINOperationQueue是怎么实现上述功能的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
pthread_mutex_t _lock;
 //increments with every operation to allow cancelation
 NSUInteger _operationReferenceCount;
 NSUInteger _maxConcurrentOperations;
 
 dispatch_group_t _group;
 
 dispatch_queue_t _serialQueue;
 BOOL _serialQueueBusy;
 
 dispatch_semaphore_t _concurrentSemaphore;
 dispatch_queue_t _concurrentQueue;
 dispatch_queue_t _semaphoreQueue;
 
 NSMutableOrderedSet<PINOperation *> *_queuedOperations;
 NSMutableOrderedSet<PINOperation *> *_lowPriorityOperations;
 NSMutableOrderedSet<PINOperation *> *_defaultPriorityOperations;
 NSMutableOrderedSet<PINOperation *> *_highPriorityOperations;
 
 NSMapTable<id<PINOperationReference>, PINOperation *> *_referenceToOperations;
 NSMapTable<NSString *, PINOperation *> *_identifierToOperations;

通过PINOperationQueue的成员变量，可以得知：

  1. 通过dispatch_semaphore_t来实现并发数控制。dispatch_semaphore_t是信号量
  2. 通过NSMutableOrderedSet实现了优先级和顺序管理。NSMutableOrderedSet是具有排序功能的集合类。
  3. 通过NSMapTable实现了绑定id和操作。NSMapTable类似NSdictionry，区别在于NSMapTable是可变的，同时键值可以为弱引用，当任何一项为nil的时候将这一项移除。同时，NSMapTable可以存储任意指针，通过指针来进行相等性和散列校验

初始化代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
- (instancetype)initWithMaxConcurrentOperations:(NSUInteger)maxConcurrentOperations concurrentQueue:(dispatch_queue_t)concurrentQueue
{
  if (self = [super init]) {
    NSAssert(maxConcurrentOperations > 1, @"Max concurrent operations must be greater than 1. If it's one, just use a serial queue!");
    _maxConcurrentOperations = maxConcurrentOperations;
    _operationReferenceCount = 0;
    
    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);
    //mutex must be recursive to allow scheduling of operations from within operations
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
    pthread_mutex_init(&_lock, &attr);
    
    _group = dispatch_group_create();
    
    _serialQueue = dispatch_queue_create("PINOperationQueue Serial Queue", DISPATCH_QUEUE_SERIAL);
    
    _concurrentQueue = concurrentQueue;
    
    //Create a queue with max - 1 because this plus the serial queue add up to max.
    _concurrentSemaphore = dispatch_semaphore_create(_maxConcurrentOperations - 1);
    _semaphoreQueue = dispatch_queue_create("PINOperationQueue Serial Semaphore Queue", DISPATCH_QUEUE_SERIAL);
    
    _queuedOperations = [[NSMutableOrderedSet alloc] init];
    _lowPriorityOperations = [[NSMutableOrderedSet alloc] init];
    _defaultPriorityOperations = [[NSMutableOrderedSet alloc] init];
    _highPriorityOperations = [[NSMutableOrderedSet alloc] init];
    
    _referenceToOperations = [NSMapTable weakToWeakObjectsMapTable];
    _identifierToOperations = [NSMapTable weakToWeakObjectsMapTable];
  }
  return self;
}

在这里，实现了一个递归锁。递归锁允许在未释放锁的时候反复的上锁，当解锁次数和等于上锁的次数的时候才PINOperationQueue可能在一个多次加锁。

并发

PINOperationQueue最大特色就是实现了并发管理操作，提供cancel，wait, Priority的功能，通过实现来看看怎么做到的。

- (void)scheduleNextOperations:(BOOL)onlyCheckSerial方法为派发operation的地方私有方法。

scheduleNextOperations执行的分为两块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
[self lock];
  //get next available operation in order, ignoring priority and run it on the serial queue
  if (_serialQueueBusy == NO) {
    PINOperation *operation = [self locked_nextOperationByQueue];
    if (operation) {
      _serialQueueBusy = YES;
      dispatch_async(_serialQueue, ^{
        operation.block(operation.data);
        for (dispatch_block_t completion in operation.completions) {
          completion();
        }
        dispatch_group_leave(_group);
        
        [self lock];
          _serialQueueBusy = NO;
        [self unlock];
        
        //see if there are any other operations
        [self scheduleNextOperations:YES];
      });
    }
  }
[self unlock];

在这里，locked_nextOperationByQueue从_queuedOperations取出第一个operation，然后异步派发到_serialQueue中执行。可以看出，这里本质是串行取出operation然后再派发到_serialQueue异步执行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
dispatch_async(_semaphoreQueue, ^{
    dispatch_semaphore_wait(_concurrentSemaphore, DISPATCH_TIME_FOREVER);
    [self lock];
      PINOperation *operation = [self locked_nextOperationByPriority];
    [self unlock];
  
    if (operation) {
      dispatch_async(_concurrentQueue, ^{
        operation.block(operation.data);
        for (dispatch_block_t completion in operation.completions) {
          completion();
        }
        dispatch_group_leave(_group);
        dispatch_semaphore_signal(_concurrentSemaphore);
      });
    } else {
      dispatch_semaphore_signal(_concurrentSemaphore);
    }
});

在这里，实现了并发，从locked_nextOperationByPriority方法中根据优先级获得一个operation，异步派发到_concurrentQueue中执行。这里通过信号量来管理并发数，当信号量为0的时候就会一直等待。

locked_nextOperationByPriority中从_highPriorityOperations取，取不到的情况下就从下一个优先级的set中取。

看懂了scheduleNextOperations，再看locked_cancelOperation就不难了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
- (BOOL)locked_cancelOperation:(id <PINOperationReference>)operationReference
{
  BOOL success = NO;
  PINOperation *operation = [_referenceToOperations objectForKey:operationReference];
  if (operation) {
    NSMutableOrderedSet *queue = [self operationQueueWithPriority:operation.priority];
    if ([queue containsObject:operation]) {
      success = YES;
      [queue removeObject:operation];
      [_queuedOperations removeObject:operation];
      dispatch_group_leave(_group);
    }
  }
  return success;
}

取消操作，主要根据operationRef来取出操作，然后从所在的优先级队列中删除对应的operation。注意到，如果这个operation已经被派发到执行队列上了，就无法取消了。

PINOperationGroup是在PINOperationQueue之上再实现的包装。

PINOperationQueue和PINOperationGroup可以看做是PINCache使用的GCD实现一套与NSOperation相似的功能。通过学习阅读这一块，可以加深对GCD异步处理的理解。

尾声

PINCache是这个系列的第二篇，个人感觉收获很大，对整个key-value缓存实现的一个思路有了更清楚的认识。

下一篇，打算看看YYCache,主要关注点是如何实现缓存淘汰算法和优化性能的。

赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家