private class Node{

        /**
         * 當前節點的id
         */
        long now;

        /**
         * id - 名稱鍵值對中的名稱
         */
        String name;

        /**
         * 前驅
         */
        Node pre;

        /**
         * 後繼
         */
        Node next;
    }

 private class HeadManager{

        /**
         * 鏈接前一個管理結構(鏈表長度小於等於當前鏈表)和後一個管理結構(鏈表長度大於等於當前鏈表)
         */
        HeadManager pre, next;

        /**
         * 當前鏈表的長度
         */
        int size = 0;
        
        /**
         * 鏈表中閑置的頭節點
        * */
        Node head = new Node();

        /**
         * 鏈表中閑置的尾節點
         */
        Node tail = new Node();
        
        {
            /*
             * 一開始讓首尾相連
             */
            head.next = tail;
            tail.pre = head;
        }
    }

public class PlatformCache {

    /**
     * 當整個散列表中的值超過這個大小，就會開始回收
     */
    private static final int MAX_SIZE = 1024;

    /**
     * 散列表所在數組的初始大小
     */
    private static final int INIT_SIZE = 64;

    private static Double rate = 0.0;

    private static Double time = 0.0;

    /**
     * 讀寫鎖
     */
    private ReentrantReadWriteLock reentrantReadWriteLock;

    /**
     * 整個散列表中的節點數
     */
    private int size;

    /**
     * 散列表
     */
    private HeadManager[] tables;

    /**
     * 管理結構鏈表中的閑置頭
     */
    private HeadManager inOrderHead;

    /**
     * 管理結構鏈表中的閑置尾
     */
    private HeadManager inOrderTail;

    /**
     * 單例
     */
    private static PlatformCache instance;

}

 
/**
* 獲取單例
*/
public static PlatformCache getInstance(){
        if(instance == null){
            synchronized (PlatformCache.class){
                if(instance == null){
                    instance = new PlatformCache();
                }
            }
        }
        return instance;
}

public String getName(long id){
        try {//鎖讀鎖 防止讀入時修改
            reentrantReadWriteLock.readLock().lock();

            //簡單散列
            int index = hash(id);
            HeadManager manager = tables[index];

            //如果管理結構不在散列表中 就讓fresh = true
            boolean fresh = false;

            if(manager != null){
                Node head = manager.head.next;
                while(head != null && head != manager.tail){

                    //命中
                    if(id == head.now){
                        reentrantReadWriteLock.readLock().unlock();
                        reentrantReadWriteLock.writeLock().lock();
                        //到這裡的時候，可能有其他執行緒操作過我們命中了的節點
                        //所以需要看一下我們的節點有沒有被刪除（前驅後繼為空）
                        if(head.pre == null || head.next == null){
                            //如果刪除了，就跳出循環，和沒命中合併成同一種情況
                            reentrantReadWriteLock.readLock().lock();
                            reentrantReadWriteLock.writeLock().unlock();
                            break;
                        }
                        //移到前面 表示最近訪問過
                        moveForward(manager, head);return head.name;
                    }
                    head = head.next;
                }
            }else{
                fresh = true;
            }

            //訪問資料庫
            Platform platform = mapper.selectByPrimaryKey(id);
            if(platform != null){
                    reentrantReadWriteLock.readLock().unlock();
                    //1
                    reentrantReadWriteLock.writeLock().lock();
                    //這裡的檢查很重要 因為在1處可能別的執行緒獲得了鎖
                    //修改了我們要訪問的index下標處的內容
                    if(tables[index] == null){
                        //創建新的 管理結構 並掛到散列表上
                        manager = new HeadManager();
                        tables[index] = manager;
                    }else{
                        //如果其他執行緒創建了管理結構
                        //那麼他們可能把我們想要的節點放到鏈表中了
                        //所以再次遍歷節點，看看能否找到
                        manager = tables[index];
                        fresh = false;
                        Node head = manager.head.next;
                        while(head != null && head != manager.tail){
                            //命中
                            if(id == head.now){
                                //下面不用加寫鎖因為當前已經獲得寫鎖
                                //移到前面 表示最近訪問過
                                moveForward(manager, head);
                                return head.name;
                            }
                            head = head.next;
                        }
                    }

                //新建一個Node
                Node more = new Node();
                more.name = platform.getPlatformName();
                more.now = platform.getPlatformId();

                //插入到鏈表中閑置頭節點的下一位
                Node now = manager.head.next;
                manager.head.next = more;
                more.next = now;
                now.pre = more;
                more.pre = manager.head;

                //更改管理結構管理的鏈表大小和總大小
                manager.size ++;
                size ++;

                if(fresh){
                    //如果新建了管理結構 就把管理結構掛入到大小隊列
                    insertBeforeHead(manager);
                }

                //管理結構的鏈表大小增加時排序管理結構隊列
                whenInc(manager);

                //超出了我們的預算，則進行回收
                if(size > MAX_SIZE){

                    if(inOrderTail.pre == inOrderHead){
                        logger.error("快取中頭和尾之間沒有快取節點!");
                        throw new ServiceException("快取錯誤已經記錄日誌");
                    }

                    //刪除鏈表長度最大的管理結構的鏈表尾節點的前一個節點
                    //inOrderTail是閑置的管理結構尾節點
                    //inOrderTail.pre是鏈表長度最大的管理結構
                    //inOrderTail.pre.tail是鏈表閑置的尾節點
                    //inOrderTail.pre.tail.pre真正需要回收的節點
                    deleteNode(inOrderTail.pre.tail.pre);

                    //管理結構的鏈表長度和散列表總大小均-1
                    inOrderTail.pre.size --;
                    size --;
                    whenDec(inOrderTail.pre);
                }

                return platform.getPlatformName();
            }
            return null;
        }finally {
            //釋放所有鎖
            try {
                //保險起見 固定釋放讀寫鎖
                try {
                    if(reentrantReadWriteLock.writeLock().isHeldByCurrentThread()){
                        reentrantReadWriteLock.writeLock().unlock();
                    }
                }catch (Exception e){
                }
                try {
                    reentrantReadWriteLock.readLock().unlock();
                }catch (Exception e){
                }
            }catch (Exception e){
                //可以寫入日誌
            }
        }

    }

　　private void deleteNode(Node node){
        Node next = node.next;
        node.pre.next = next;
        next.pre = node.pre;
        node.pre = node.next = null;
    }

    /**
     * 往後找，找到鏈表長度比自己小的管理結構，並且插到他後面
     */
    private void whenInc(HeadManager manager){
        HeadManager back = manager.next;

        while(back.size < manager.size && back != inOrderTail){

            back = back.next;
        }

        manager.pre.next = manager.next;
        manager.next.pre = manager.pre;

        HeadManager pre = back.pre;
        pre.next = manager;
        manager.pre = pre;

        back.pre = manager;
        manager.next = back;

    }

    private void insertBeforeHead(HeadManager manager) {
        HeadManager now = inOrderHead.next;

        inOrderHead.next = manager;
        manager.next = now;

        now.pre = manager;
        manager.pre = inOrderHead;
    }

    private int hash(Long id){
        Long tmp = id;
        id ^= tmp >>> 32;
        id ^= tmp >>> 16;
        id ^= tmp >>> 8;
        id ^= tmp >>> 4;
        return Math.toIntExact(id & (tables.length - 1));
    }

    /**
     * 往前找，找到鏈表長度比自己大的管理結構，並且插到他前面
     */
    private void whenDec(HeadManager manager){
        HeadManager front = manager.pre;

        while(front.size > manager.size && front != inOrderHead){
            front = front.pre;
        }
        manager.pre.next = manager.next;
        manager.next.pre = manager.pre;

        HeadManager next = front.next;
        front.next = manager;
        next.pre = manager;

        manager.pre = front;
        manager.next = next;
    }

　　 //被訪問的節點放在鏈表頭部
    private void moveForward(HeadManager manager, Node head){
        Node now = manager.head;

        Node next = head.next;
        head.pre.next = next;
        next.pre = head.pre;

        head.pre = now;
        head.next = now.next;
        now.next.pre = head;
        now.next = head;
    }

int index = Math.toIntExact((id & (tables.length - 1)));

private int hash(Long id){
        id |= id >> 8;
        id |= id >> 8;
        id |= id >> 8;
        id |= id >> 8;
        return Math.toIntExact(id & (tables.length - 1));
 }

  private int hash(Long id){
        Long tmp = id;
        id ^= tmp >>> 32;
        id ^= tmp >>> 16;
        id ^= tmp >>> 8;
        id ^= tmp >>> 4;
        return Math.toIntExact(id & (tables.length - 1));
    }