LRU实现方法

/*
 *   Copyright (c) 2020 wcx
 *   All rights reserved.
 */
/*
    关于LRU实现的四种方法： LRU(least recently used最近最久未使用)
    （1）数组实现，利用时间戳每次删除最大的，但是切换次数多了可能就爆int
    （2）链表插入删除（每次找到就插入到前面，没有就直接插入）
    （3) unorder_map+链表  o(1)实现
*/
#include <bits/stdc++.h>
#include <unordered_map>
#include <mutex>
using namespace std;
struct node{
    node *next;
    node *prev;
    int val;
};
namespace LRU1{
    // 每个页面用一个id刻画
    const int maxn = 1e5+10;
    class LRU{
    public:
        unordered_map<int,node *> ma;
        node *head=NULL;
        node *tail=NULL;
        LRU(int maxSize = 4){ //初始化size等
            this->maxSize=maxSize;
            this->nowSize=0;
            head=(node*)malloc(sizeof(node));
            if(head==NULL){
                cout<<"malloc error"<<endl;
                exit(-1);
            }
        }
        void addPage(int val){
            mLock.lock();  
            if(ma[val]){ // 原来里面有
                node *p=ma[val];
                if(tail==p){
                    // 处于尾部位置
                    tail=p->prev;
                    if(tail==head) tail=NULL;
                }
                if(head!=NULL&&head->next==p){
                    mLock.unlock();
                }
                p->prev->next=p->next;
                if(p->next!=NULL) p->next->prev=p->prev;
                p->prev=head;
                p->next=head->next;
                head->next=p;
            }
            else{
                if(nowSize>=maxSize){
                    //删除最后一个
                    node *t=tail;
                    tail=tail->prev;
                    tail->next=NULL;
                    if(tail==head) tail=NULL;
                    delete t;
                }
                do{
                    node *p=(node*)malloc(sizeof(node));
                    if(p==NULL){
                        mLock.unlock();
                        cout<<"malloc error"<<endl; 
                        exit(-1);
                    }
                    if(tail==NULL) tail=p;
                    p->next=head->next;
                    if(p->next!=NULL) p->next->prev=p;
                    p->prev=head;
                    head->next=p;
                    p->val=val;
                    ma[val]=p;
                }while(0);
                ++nowSize;   
                mLock.unlock();           
            }
        }
        void getAll(){
            mLock.lock();
            node *p=head->next;
            while(p!=NULL){
                cout<<p->val<<" ";
                p=p->next;
            }
            cout<<endl;
            mLock.unlock();  
            return;
        }
        static LRU* getInstance(){
            static LRU *lru;
            if(lru==NULL){
                lru=new LRU();
            }
            return lru;
        } 
    private:
        int maxSize;
        int nowSize;
        static LRU *lru;
        mutex mLock;
    };
}
int main(){
    LRU1::LRU::getInstance()->addPage(1);
    LRU1::LRU::getInstance()->addPage(4);
    LRU1::LRU::getInstance()->addPage(3);
    LRU1::LRU::getInstance()->addPage(5);
    LRU1::LRU::getInstance()->addPage(1);
    LRU1::LRU::getInstance()->getAll();
    
}