let cache: NSCache<NSString, UIImage> = NSCache()
cache.countLimit = // 허용하는 key의 개수
cache.totalCostLimit = // cost 합계의 최댓값

open class NSCache<KeyType, ObjectType> : NSObject where KeyType : AnyObject, ObjectType : AnyObject {
  
    open var name: String
  
    unowned(unsafe) open var delegate: NSCacheDelegate?
    
    open var totalCostLimit: Int // limits are imprecise/not strict

    open var countLimit: Int // limits are imprecise/not strict

    open var evictsObjectsWithDiscardedContent: Bool
}

private class NSCacheEntry<KeyType : AnyObject, ObjectType : AnyObject> {
    var key: KeyType
    var value: ObjectType
    var cost: Int
    var prevByCost: NSCacheEntry?
    var nextByCost: NSCacheEntry?
    init(key: KeyType, value: ObjectType, cost: Int) {
        self.key = key
        self.value = value
        self.cost = cost
    }
}

open class NSCache<KeyType : AnyObject, ObjectType : AnyObject> : NSObject {
    
    private var _entries = Dictionary<NSCacheKey, NSCacheEntry<KeyType, ObjectType>>()
    private let _lock = NSLock()
    private var _totalCost = 0
    private var _head: NSCacheEntry<KeyType, ObjectType>?
    
    open var name: String = ""
    open var totalCostLimit: Int = 0 // limits are imprecise/not strict
    open var countLimit: Int = 0 // limits are imprecise/not strict
    open var evictsObjectsWithDiscardedContent: Bool = false
		...

private func insert(_ newEntry: NSCacheEntry<KeyType, ObjectType>) {
  // 1. _head 가 비어있다면 맨앞에 새로 추가된 entry 삽입
        guard var currentElement = _head else {
            // The cache is empty
            newEntry.prevByCost = nil
            newEntry.nextByCost = nil
            
            _head = newEntry
            return
        }
        // 2. _head보다 cost가 작거나 같은 것이 들어올 경우 _head 앞에 삽입
        guard newEntry.cost > currentElement.cost else {
            // Insert entry at the head
            newEntry.prevByCost = nil
            newEntry.nextByCost = currentElement
            currentElement.prevByCost = newEntry
            
            _head = newEntry
            return
        }
        // 3. 순회를 통해 삽입 될 곳의 위치를 찾는다.
        while let nextByCost = currentElement.nextByCost, nextByCost.cost < newEntry.cost {
            currentElement = nextByCost
        }
        
        // Insert entry between currentElement and nextElement
  			// 순서가 중요
        let nextElement = currentElement.nextByCost
        
        currentElement.nextByCost = newEntry
        newEntry.prevByCost = currentElement
        
        newEntry.nextByCost = nextElement
        nextElement?.prevByCost = newEntry
    }

    private func remove(_ removeEntry: NSCacheEntry<KeyType, ObjectType>) {
        let oldPrev = removeEntry.prevByCost
        let oldNext = removeEntry.nextByCost
        
        oldPrev?.nextByCost = oldNext
        oldNext?.prevByCost = oldPrev
        // 삭제할 entry가 head 인 경우 next의 값을 연결 시킨다.
        if removeEntry === _head {
            _head = oldNext
        }
    }

open func setObject(_ obj: ObjectType, forKey key: KeyType, cost g: Int) {
        let g = max(g, 0)
        let keyRef = NSCacheKey(key)
        
        _lock.lock()
        
        let costDiff: Int
        // 추가된 객체와 같은 키를 갖는 엔트리를 찾는다.
        if let entry = _entries[keyRef] {
          // 같은 엔트리를 우선 찾고 cost의 차이를 계산
            costDiff = g - entry.cost
          // 추가된 객체의 cost로 업데이트
            entry.cost = g
            // 추가된 객체로 업데이트
            entry.value = obj
            // 만약 cost의 차이가 있다면(같지 않다면) cost가 변경된 기존의 entry를 삭제하고
            // 올바른 위치로 갈수 있게 재 삽입
            if costDiff != 0 {
                remove(entry)
                insert(entry)
            }
        } else {
          // 기존에 같은 키를 갖는 엔트리가 없는 경우 새롭게 NSCacheEntry 생성 후 삽입
            let entry = NSCacheEntry(key: key, value: obj, cost: g)
            _entries[keyRef] = entry
            insert(entry)
            
            costDiff = g
        }
        
        _totalCost += costDiff
       // cost 제한이 있다면, 새로 추가된 엔트리의 cost를 포함한 totalCost에서 totalLimitCost를 뺀 			// 값을 purgeAmount에 할당한다. 제한이 없다면 0을 할당한다.
        var purgeAmount = (totalCostLimit > 0) ? (_totalCost - totalCostLimit) : 0
  		// totalCost ≤ totalLimitCost 일때 까지 
        while purgeAmount > 0 {
          // 엔트리 축출 작업은 _head 엔트리 부터 제거한다.
            if let entry = _head {
                delegate?.cache(unsafeDowncast(self, to:NSCache<AnyObject, AnyObject>.self), willEvictObject: entry.value)
                
                _totalCost -= entry.cost
                purgeAmount -= entry.cost
                
                remove(entry) // _head will be changed to next entry in remove(_:)
                _entries[NSCacheKey(entry.key)] = nil
            } else {
                break
            }
        }
        // countLimit 에도 동일한 작업을 수행
        var purgeCount = (countLimit > 0) ? (_entries.count - countLimit) : 0
        while purgeCount > 0 {
            if let entry = _head {
                delegate?.cache(unsafeDowncast(self, to:NSCache<AnyObject, AnyObject>.self), willEvictObject: entry.value)
                
                _totalCost -= entry.cost
                purgeCount -= 1
                
                remove(entry) // _head will be changed to next entry in remove(_:)
                _entries[NSCacheKey(entry.key)] = nil
            } else {
                break
            }
        }
        
        _lock.unlock()
    }