首页 / 缓存 / mysql实现本地keyvalue数据库缓存示例

mysql实现本地keyvalue数据库缓存示例

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了mysql实现本地keyvalue数据库缓存示例，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含11611字，纯文字阅读大概需要17分钟。

内容图文

Key-Value缓存有很多，用的较多的是memcache、redis，他们都是以独立服务的形式运行，在工作中有时需要嵌入一个本地的key-value缓存，当然已经有LevelDb等，但感觉还是太重量级了。

本文实现了一种超级轻量的缓存，

1、实现代码仅仅需要400行；

2、性能高效，value长度在1K时测试速度在每秒200万左右

3、缓存是映射到文件中的，所以没有malloc、free的开销，以及带来的内存泄露、内存碎片等；

4、如果服务挂掉了，重启后缓存内容继续存在；

5、如果把缓存映射到磁盘文件就算机器挂了，缓存中内容还是会存在，当然有可能会出现数据损坏的情况；

6、一定程度上实现了LRU淘汰算法，实现的LRU不是全局的只是一条链上的，所以只能说在一定程序上实现了；

7、稳定，已经在多个项目中运用，线上部署的机器有几十台，运行了大半年了没出过问题；

8、普通的缓存key、value都是字符串的形式，此缓存的key、value都可以是class、struct对象结构使用更方便；

老规矩直接上代码：

代码如下:

 template<typename K, typename V>
class HashTable
{
public:
    HashTable(const char *tablename, uint32_t tableLen, uint32_t nodeTotal);
    virtual ~HashTable();

    bool Add(K &key, V &value)
    {
        AutoLock autoLock(m_MutexLock);

        //check is exist
        uint32_t nodeId = GetIdByKey(key);
        if(nodeId != m_InvalidId) return false;

        nodeId = GetFreeNode();
        if(nodeId == m_InvalidId) return false;

        uint32_t hashCode = key.HashCode();
        Entry *tmpNode = m_EntryAddr + nodeId;
        tmpNode->m_Key = key;
        tmpNode->m_Code = hashCode;
        tmpNode->m_Value = value;

        uint32_t index = hashCode % m_HeadAddr->m_TableLen;
        AddNodeToHead(index, nodeId);

        return true;
    }

    bool Del(K &key)
    {
        AutoLock autoLock(m_MutexLock);

        uint32_t nodeId = GetIdByKey(key);
        if(nodeId == m_InvalidId) return false;

        uint32_t index = key.HashCode() % m_HeadAddr->m_TableLen;

        return RecycleNode(index, nodeId);
    }

    bool Set(K &key, V &value)
    {
        AutoLock autoLock(m_MutexLock);

        uint32_t nodeId = GetIdByKey(key);
        if(nodeId == m_InvalidId) return false;

        (m_EntryAddr + nodeId)->m_Value = value;

        return true;
    }

    bool Get(K &key, V &value)
    {
        AutoLock autoLock(m_MutexLock);

        uint32_t nodeId = GetIdByKey(key);
        if(nodeId == m_InvalidId) return false;

        value = (m_EntryAddr + nodeId)->m_Value;

        return true;
    }

    bool Exist(K &key)
    {
        AutoLock autoLock(m_MutexLock);

        uint32_t nodeId = GetIdByKey(key);
        if(nodeId == m_InvalidId) return false;

        return true;
    }

    uint32_t Count()
    {
        AutoLock autoLock(m_MutexLock);
        return m_HeadAddr->m_UsedCount;
    }

    //if exist set else add
    bool Replace(K &key, V &value)
    {
        AutoLock autoLock(m_MutexLock);

        if(Exist(key)) return Set(key, value);
        else return Add(key, value);
    }

    /***********************************************
    ****LRU: when visit a node, move it to head ****
    ************************************************/
    //if no empty place,recycle tail
    bool LruAdd(K &key, V &value, K &recyKey, V &recyValue, bool &recycled)
    {
        AutoLock autoLock(m_MutexLock);

        if(Exist(key)) return false;

        if(Add(key, value)) return true;

        uint32_t index = key.HashCode() % m_HeadAddr->m_TableLen;
        uint32_t tailId = GetTailNodeId(index);

        if(tailId == m_InvalidId) return false;

        Entry *tmpNode = m_EntryAddr + tailId;
        recyKey   = tmpNode->m_Key;
        recyValue = tmpNode->m_Value;
        recycled  = true;

        RecycleNode(index, tailId);

        return Add(key, value);
    }

    bool LruSet(K &key, V &value)
    {
        AutoLock autoLock(m_MutexLock);

        if(Set(key, value)) return MoveToHead(key);
        else return false;
    }

    bool LruGet(K &key, V &value)
    {
        AutoLock autoLock(m_MutexLock);

        if(Get(key, value)) return MoveToHead(key);
        else return false;
    }

    //if exist set else add; if add failed recycle tail than add
    bool LruReplace(K &key, V &value, K &recyKey, V &recyValue, bool &recycled)
    {
        AutoLock autoLock(m_MutexLock);

        recycled = false;

        if(Exist(key)) return LruSet(key, value);
        else return LruAdd(key, value, recyKey, recyValue, recycled);
    }

    void Clear()
    {
        AutoLock autoLock(m_MutexLock);

        m_HeadAddr->m_FreeBase = 0;
        m_HeadAddr->m_RecycleHead = 0;
        m_HeadAddr->m_UsedCount = 0;
        for(uint32_t i = 0; i < m_HeadAddr->m_TableLen; ++i)
        {
            (m_ArrayAddr+i)->m_Head = m_InvalidId;
            (m_ArrayAddr+i)->m_Tail = m_InvalidId;
        }
    }

    int GetRowKeys(vector<K> &keys, uint32_t index)
    {
        AutoLock autoLock(m_MutexLock);

        if(index >= m_HeadAddr->m_TableLen) return -1;

        keys.clear();
        keys.reserve(16);

        int count = 0;
        Array *tmpArray = m_ArrayAddr + index;
        uint32_t nodeId = tmpArray->m_Head;
        while(nodeId != m_InvalidId)
        {
            Entry *tmpNode = m_EntryAddr + nodeId;
            keys.push_back(tmpNode->m_Key);
            nodeId = tmpNode->m_Next;
            ++count;
        }

        return count;
    }

    void *Padding(uint32_t size)
    {
        AutoLock autoLock(m_MutexLock);

        if(size > m_HeadSize - sizeof(TableHead)) return NULL;
        else return m_HeadAddr->m_Padding;
    }

private:
    static const uint32_t m_InvalidId = 0xffffffff;
    static const uint32_t m_HeadSize = 1024;
    struct TableHead
    {
        uint32_t m_TableLen;
        uint32_t m_NodeTotal;
        uint32_t m_FreeBase;
        uint32_t m_RecycleHead;
        uint32_t m_UsedCount;
        char     m_TableName[256];
        uint32_t m_Padding[0];
    };

    struct Array
    {
        uint32_t m_Head;
        uint32_t m_Tail;
    };

    struct Entry
    {
        V m_Value;
        K m_Key;
        uint32_t m_Code;
        uint32_t m_Next;
        uint32_t m_Prev;
    };

    size_t     m_MemSize;
    uint8_t   *m_MemAddr;
    TableHead *m_HeadAddr;
    Array     *m_ArrayAddr;
    Entry     *m_EntryAddr;

    ThreadMutex m_MutexLock;

    bool MoveToHead(K &key);
    uint32_t GetIdByKey(K &key);
    void AddNodeToHead(uint32_t index, uint32_t nodeId);
    bool MoveNodeToHead(uint32_t index, uint32_t nodeId);
    bool RecycleNode(uint32_t index, uint32_t nodeId);
    uint32_t GetTailNodeId(uint32_t index);
    uint32_t GetFreeNode();

    DISABLE_COPY_AND_ASSIGN(HashTable);
};

template<typename K, typename V>
HashTable<K, V>::HashTable(const char *tablename, uint32_t tableLen, uint32_t nodeTotal)
{
    AbortAssert(tablename != NULL);

    m_MemSize = m_HeadSize + tableLen*sizeof(Array) + nodeTotal*sizeof(Entry);
    m_MemAddr = (uint8_t*)MemFile::Realloc(tablename, m_MemSize);
    AbortAssert(m_MemAddr != NULL);

    m_HeadAddr = (TableHead*)(m_MemAddr);
    m_ArrayAddr = (Array*)(m_MemAddr + m_HeadSize);
    m_EntryAddr = (Entry*)(m_MemAddr + m_HeadSize + tableLen*sizeof(Array));

    m_HeadAddr->m_TableLen = tableLen;
    m_HeadAddr->m_NodeTotal = nodeTotal;
    strncpy(m_HeadAddr->m_TableName, tablename, sizeof(m_HeadAddr->m_TableName));

    if(m_HeadAddr->m_UsedCount == 0)//if first use init array to invalid id 
    {
        for(uint32_t i = 0; i < tableLen; ++i)
        {
            (m_ArrayAddr+i)->m_Head = m_InvalidId;
            (m_ArrayAddr+i)->m_Tail = m_InvalidId;
        }

        m_HeadAddr->m_FreeBase = 0;
        m_HeadAddr->m_RecycleHead = 0;
    }
}

template<typename K, typename V>
HashTable<K, V>::~HashTable()
{
    MemFile::Release(m_MemAddr, m_MemSize);
}

template<typename K, typename V>
bool HashTable<K, V>::MoveToHead(K &key)
{
    uint32_t nodeId = GetIdByKey(key);
    uint32_t index = key.HashCode() % m_HeadAddr->m_TableLen;

    return MoveNodeToHead(index, nodeId);
}

template<typename K, typename V>
uint32_t HashTable<K, V>::GetIdByKey(K &key)
{
    uint32_t hashCode = key.HashCode();
    uint32_t index = hashCode % m_HeadAddr->m_TableLen;
    Array *tmpArray = m_ArrayAddr + index;

    uint32_t nodeId = tmpArray->m_Head;
    while(nodeId != m_InvalidId)
    {
        Entry *tmpNode = m_EntryAddr + nodeId;
        if(tmpNode->m_Code == hashCode && key.Equals(tmpNode->m_Key)) break;

        nodeId = tmpNode->m_Next;
    }

    return nodeId;
}

template<typename K, typename V>
void HashTable<K, V>::AddNodeToHead(uint32_t index, uint32_t nodeId)
{
    if(index >= m_HeadAddr->m_TableLen || nodeId >= m_HeadAddr->m_NodeTotal) return;

    Array *tmpArray = m_ArrayAddr + index;
    Entry *tmpNode = m_EntryAddr + nodeId;
    if(m_InvalidId == tmpArray->m_Head)
    {
        tmpArray->m_Head = nodeId;
        tmpArray->m_Tail = nodeId;
    }
    else
    {
        tmpNode->m_Next = tmpArray->m_Head;
        (m_EntryAddr + tmpArray->m_Head)->m_Prev = nodeId;
        tmpArray->m_Head = nodeId;
    }
}

template<typename K, typename V>
bool HashTable<K, V>::MoveNodeToHead(uint32_t index, uint32_t nodeId)
{
    if(index >= m_HeadAddr->m_TableLen || nodeId >= m_HeadAddr->m_NodeTotal) return false;

    Array *tmpArray = m_ArrayAddr + index;
    Entry *tmpNode = m_EntryAddr + nodeId;

    //already head
    if(tmpArray->m_Head == nodeId)
    {
        return true;
    }

    uint32_t nodePrev = tmpNode->m_Prev;
    uint32_t nodeNext = tmpNode->m_Next;
    (m_EntryAddr+nodePrev)->m_Next = nodeNext;
    if(nodeNext != m_InvalidId)
    {
        (m_EntryAddr+nodeNext)->m_Prev = nodePrev;
    }
    else
    {
        tmpArray->m_Tail = nodePrev;
    }

    tmpNode->m_Prev = m_InvalidId;
    tmpNode->m_Next = tmpArray->m_Head;
    (m_EntryAddr + tmpArray->m_Head)->m_Prev = nodeId;
    tmpArray->m_Head = nodeId;

    return true;
}

template<typename K, typename V>
bool HashTable<K, V>::RecycleNode(uint32_t index, uint32_t nodeId)
{
    if(index >= m_HeadAddr->m_TableLen || nodeId >= m_HeadAddr->m_NodeTotal) return false;

    Array *tmpArray = m_ArrayAddr + index;
    Entry *tmpNode = m_EntryAddr + nodeId;

    uint32_t nodePrev = tmpNode->m_Prev;
    uint32_t nodeNext = tmpNode->m_Next;

    if(nodePrev != m_InvalidId)
    {
        (m_EntryAddr + nodePrev)->m_Next = nodeNext;
    }
    else
    {
        tmpArray->m_Head = nodeNext;
    }

    if(nodeNext != m_InvalidId)
    {
        (m_EntryAddr + nodeNext)->m_Prev = nodePrev;
    }
    else
    {
        tmpArray->m_Tail = nodePrev;
    }

    (m_EntryAddr+nodeId)->m_Next = m_HeadAddr->m_RecycleHead;
    m_HeadAddr->m_RecycleHead = nodeId;
    --(m_HeadAddr->m_UsedCount);

    return true;
}

template<typename K, typename V>
uint32_t HashTable<K, V>::GetTailNodeId(uint32_t index)
{
    if(index >= m_HeadAddr->m_TableLen) return m_InvalidId;

    Array *tmpArray = m_ArrayAddr + index;

    return tmpArray->m_Tail;
}

template<typename K, typename V>
uint32_t HashTable<K, V>::GetFreeNode()
{
    uint32_t nodeId = m_InvalidId;
    if(m_HeadAddr->m_UsedCount < m_HeadAddr->m_FreeBase)//get from recycle list
    {
        nodeId = m_HeadAddr->m_RecycleHead;
        m_HeadAddr->m_RecycleHead = (m_EntryAddr+nodeId)->m_Next;
        ++(m_HeadAddr->m_UsedCount);
    }
    else if(m_HeadAddr->m_UsedCount < m_HeadAddr->m_NodeTotal)//get from free mem
    {
        nodeId = m_HeadAddr->m_FreeBase;
        ++(m_HeadAddr->m_FreeBase);
        ++(m_HeadAddr->m_UsedCount);
    }
    else
    {
        nodeId = m_InvalidId;
    }

    //init node
    if(nodeId < m_HeadAddr->m_NodeTotal)
    {
        Entry *tmpNode = m_EntryAddr + nodeId;
        memset(tmpNode, 0, sizeof(Entry));

        tmpNode->m_Next = m_InvalidId;
        tmpNode->m_Prev = m_InvalidId;
    }

    return nodeId;
}
 

您可能感兴趣的文章:

深入分析缓存依赖中cachedependency对象及周边小讲
asp.net开发中怎样去突破文件依赖缓存
开启SQLSERVER数据库缓存依赖优化网站性能
SQL Server 高速缓存依赖分析
使用Memcache缓存mysql数据库操作的原理和缓存过程浅析
asp.net 备份和恢复数据库的方法示例
asp.net连接数据库读取数据示例分享
asp.net 通用的连接数据库实例代码
ASP.NET数据库缓存依赖实例分析

内容总结

以上是互联网集市为您收集整理的mysql实现本地keyvalue数据库缓存示例全部内容，希望文章能够帮你解决mysql实现本地keyvalue数据库缓存示例所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/584823.html

来源：【匿名】

【上一篇】浅析MySQL内存的使用说明（全局缓存+线程缓存）【下一篇】屏蔽浏览器缓存另类方法

更多 ►

【mysql实现本地keyvalue数据库缓存示例】教程文章相关的互联网学习教程文章

memcached做数据库缓存【代码】【图】

安装篇请参考http://my.oschina.net/flynewton/blog/9694Python-memcached的基本使用参考http://my.oschina.net/flynewton/blog/10660 最近研究memcache小有成果，把经验分享出来。白话:很早就听说memcache了，一直没搞懂，后来又看到redis很火，可以用来做缓存，研究了半天也没搞懂咋个做缓存，后来也不纠结了，继续学习python,当对python基础有一定掌握后，渐渐明白如何用redis或memcache做数据库的缓存。原理很简单，memcache和...

Redis（非关系型数据库，主要用于做缓存）【图】

1.1. 什么是NoSql　　NoSQL(NoSQL = Not Only SQL )，意即“不仅仅是SQL”，它泛指非关系型的数据库。随着互联网2003年之后web2.0网站的兴起，传统的关系数据库在应付web2.0网站，特别是超大规模和高并发的交友类型的web2.0纯动态网站已经显得力不从心，暴露了很多难以克服的问题，而非关系型的数据库则由于其本身的特点得到了非常迅速的发展。　　关系型数据库:以关系(由行和列组成的二维表)模型为核心数据库. 有表的储存系统 RDB...

Android 开源项目android-open-project工具库解析之(一) 依赖注入,图片缓存,网络相关,数据库orm工具包,Android公共库【图】

一、依赖注入DI 通过依赖注入减少View、服务、资源简化初始化，事件绑定等重复繁琐工作 AndroidAnnotations(Code Diet) android快速开发框架项目地址：https://github.com/excilys/androidannotations 文档介绍：https://github.com/excilys/androidannotations/wiki 官网网址：http://androidannotations.org/ 特点：(1) 依赖注入：包括view，extras，系统服务，资源等等 (2) 简单的线程模型，通过annotation表示方法运行在ui线程...

Java环境配置数据库缓存Redis Nosql MongoDB 安装【代码】

系统选择centos 7.0 1、java安装篇rpm -qa |grep java 检测是否java yum remove java-1.7.0-openjdk 使用命令删除java到oracle官方下载java安装包rpm -ivh jdk-7u60-linux-x64.rpm ->安装jdk 2、Tomcat安装篇在apache官方下载tomcat wget http://apache.fayea.com/apache-mirror/tomcat/tomcat-7/v7.0.54/bin/apache-tomcat-7.0.54.tar.gztar -zxf apache-tomcat-7.0.54.tar.gz/sbin/iptables -I INPUT -p tcp --dport 8080 -j A...

TimesTen 应用层数据库缓存学习：18. 利用TimesTen实现Sharding或数据分区【代码】

考虑到恢复和磁盘加载到内存的速度，单个TimesTen数据库可以缓存的数据一般不超过100G，如果需要缓存的数据较大，一般可以利用多个TimesTen来实现数据分区或分片(Sharding)。虽然TimesTen有Cache Grid即Global Cache Group的概念，但由于其还不太成熟，一般采用手工分区的方式，即通过应用服务器定向到指定的TimesTen的方式。以下给出了只读和读写数据分区的例子。另外强调一点，TimesTen没有Oracle Partition的概念。TimesTen c...

高并发下缓存与数据库双写不一致解决方案【图】

1、最初级的缓存不一致问题以及解决方案问题：先修改数据库，再删除缓存，如果删除缓存失败了，那么会导致数据库中是新数据，缓存中是旧数据，数据出现不一致。解决思路：　　先删除缓存，再修改数据库，如果删除缓存成功了修改数据库失败了，那么数据库中是旧数据，缓存中是空的，那么数据不会不一致，因为读的时候缓存没有，则读数据库中旧数据，然后更新到缓存中。2、并发下数据缓存不一致问题分析问题：　　第一个请求数据发生...

redis缓存数据库【代码】

一、Redis介绍redis是业界主流的key-value nosql 数据库之一。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redi...

java模拟数据库缓存【代码】

实现缓存一些数据到本地，避免重复查询数据库，对数据库造成压力，代码如下：package threadLock;import java.util.HashMap; import java.util.Map; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock;publicclass CatheDemo {private Map<String, Object> map = new HashMap<String, Object>();private ReadWriteLock rwl = new ReentrantReadWriteLock(); //定义读写...

缓存 - 最热教程

微信小程序如何修改本地缓存key中单个数...Yii清理缓存的方法_PHP .Net 性能优化--缓存--分布式缓存 --sq...SQL Server 缓存清除与内存释放详解微信小程序缓存--缓存时效性 Ajax清除浏览器js、css、图片缓存的方法 node.js利用redis数据库缓存数据 Apache缓存相关配置_PHP教程 [apicloud缓存和数据库同步]APICloud 获...Java servlet如何禁用页面缓存

首页 / 缓存 / mysql实现本地keyvalue数据库缓存示例

mysql实现本地keyvalue数据库缓存示例

内容导读

内容图文

您可能感兴趣的文章:

内容总结

内容备注

内容手机端

【mysql实现本地keyvalue数据库缓存示例】教程文章相关的互联网学习教程文章

memcached做数据库缓存【代码】【图】

Redis（非关系型数据库，主要用于做缓存）【图】

Android 开源项目android-open-project工具库解析之(一) 依赖注入,图片缓存,网络相关,数据库orm工具包,Android公共库【图】

Java环境配置数据库缓存Redis Nosql MongoDB 安装【代码】

TimesTen 应用层数据库缓存学习：18. 利用TimesTen实现Sharding或数据分区【代码】

高并发下缓存与数据库双写不一致解决方案【图】

redis缓存数据库【代码】

java模拟数据库缓存【代码】

mysql实现本地keyvalue数据库缓存示例

php实现数据库数据读取生成缓存文件【代码】

Redis缓存和数据库一致性问题【代码】【图】

5个方案告诉你：高并发环境下，先操作数据库还是先操作缓存？

缓存和数据库数据一致性

初学Redis（2）——用Redis作为Mysql数据库的缓存

MYSQL - 相关标签

数据库 - 相关标签

缓存 - 相关标签

缓存 - 最新教程

缓存 - 最热教程