NSCache 里面的实现

1， 首先是NSCache 的初始化，这里NSCache相当一个容器

@implementation NSCache

• (id) init
  {
  if (nil == (self = [super init]))
  {
  return nil;
  }
  _objects = [NSMutableDictionary new]; //用来存真正的object数据
  _accesses = [NSMutableArray new]; //用来存缓存的数据
  return self;
  }

2， 需要设计一个 Cached 对象结构来保存一些额外的信息

@interface _GSCachedObject : NSObject
{
@public
id object; //cache 的值
NSString *key; //设置 cache 的 key
int accessCount; //保存访问次数，用于自动清理
NSUInteger cost; //setObject:forKey:cost:
BOOL isEvictable; //线程安全
}
@end

3，获取Cache对象做了什么操作：去_objects 里面获取数据，然后把_accesses 里面旧的数据删除，添加新的对象，对象的accessAcount 会增加，总的_totalAccesses也增加。

• (id) objectForKey: (id)key
  {
  _GSCachedObject *obj = [_objects objectForKey: key];
  if (nil == obj)
  {
  return nil;
  }
  if (obj->isEvictable) //保证添加删除操作线程安全
  {
  // 将 obj 移到 access list 末端
  [_accesses removeObjectIdenticalTo: obj];
  [_accesses addObject: obj];
  }
  obj->accessCount++;
  _totalAccesses++;
  return obj->object;
  }

4， 添加缓存对象做了什么：1， 检查需不需要删除缓存 ； 2 如果有对象在里面， _objects 里面删除掉，_accesses 里面也删除， 3 _totalCost 要添加

• (void) setObject: (id)obj forKey: (id)key cost: (NSUInteger)num
  {
  _GSCachedObject *oldObject = [_objects objectForKey: key];
  _GSCachedObject *newObject;

  if (nil != oldObject)
  {
  [self removeObjectForKey: oldObject->key];
  }
  [self _evictObjectsToMakeSpaceForObjectWithCost: num];
  newObject = [_GSCachedObject new];
  // Retained here, released when obj is dealloc'd
  newObject->object = RETAIN(obj);
  newObject->key = RETAIN(key);
  newObject->cost = num;
  if ([obj conformsToProtocol: @protocol(NSDiscardableContent)])
  {
  newObject->isEvictable = YES;
  [_accesses addObject: newObject];
  }
  [_objects setObject: newObject forKey: key];
  RELEASE(newObject);
  _totalCost += num;
  }

5， 那么清理机制是什么呢？_totalCost + 新object的cost 比 costlimit 要大， 或者说缓存的数量 比 countLimit 要大了。都可以做清理操作

// cost 在添加新 cache 值时指定的 cost
// _costLimit 是 totalCostLimit 属性值
if (_costLimit > 0 && _totalCost + cost > _costLimit){
spaceNeeded = _totalCost + cost - _costLimit;
}
// 只有当 cost 大于人工限制时才会清理
// 或者 cost 设置为0不进行人工干预
if (count > 0 && (spaceNeeded > 0 || count >= _countLimit))

6， 清理的时候，那些经常访问到的可以先不清理，主要是通过 _totalAccesses 和总数获得平均访问频率，如果那个对象的访问次数是小于平均值的才需要清理。
//_totalAccesses 所有的值的访问都会 +1
NSUInteger averageAccesses = (_totalAccesses / count * 0.2) + 1;
//accessCount 每次 obj 取值时会 +1
if (obj->accessCount < averageAccesses && obj->isEvictable)

清理的时候会触发remove方法

• (void) removeObjectForKey: (id)key
  {
  _GSCachedObject *obj = [_objects objectForKey: key];

  if (nil != obj)
  {
  [_delegate cache: self willEvictObject: obj->object];
  _totalAccesses -= obj->accessCount;
  [_objects removeObjectForKey: key];
  [_accesses removeObjectIdenticalTo: obj];
  }
  }

总结：NSCache的清除机制是LRU （last recent used）来清除的，通过排序，然后删除，然后判断有没有达到totalCostLimit 和 CountLimit ，如果达到要求，则清理动作结束。