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

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;
}

(0)

相关推荐

  • 使用Memcache缓存mysql数据库操作的原理和缓存过程浅析

    对于大型网站如facebook,ebay等网站,如果没有Memcache做为中间缓存层,数据访问不可能吃得消,对于一般网站,只要具备独立的服务器,完全可以通过配置Memcache提高网站访问速度和减少数据库压力,这里主要讨论一下Memcache和MySQL数据库交互过程的流程关系,了解Memcache的中间缓存层作用,从而深入了解Memcache机制原理. Memcache和MySQL交互流程图 如上图,传统的查询方法是直接查询数据库,数据库将结果返回给查询语句,而当有Memcache中间缓存层

  • asp.net 通用的连接数据库实例代码

    View Code 复制代码 代码如下: <%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %> <center><h2><font face="宋体">访问数据库的通用代码实例</font></h2>

  • asp.net 备份和恢复数据库的方法示例

    复制代码 代码如下: /********************************************************************************** * * 功能说明:备份和恢复SQL Server数据库 * 作者: 刘功勋; * 版本:V0.1(C#2.0);时间:2007-1-1 * 当使用SQL Server时,请引用 COM组件中的,SQLDMO.dll组件 * 当使用Access中,请浏览添加引用以下两个dll *          引用C:\P

  • asp.net开发中怎样去突破文件依赖缓存

    在Web项目中可以使用Session,Application等来缓存数据,也可以使用Cache来缓存. 今天我们特别关注的是Cache缓存.Cache位于命名空间System.Web.Caching命名空间下,看到这里我们想到的是它在Web项目中使用. 说明:Cache 类不能在 ASP.NET 应用程序外使用.它是为在 ASP.NET 中用于为 Web 应用程序提供缓存而设计和测试的.在其他类型的应用程序(如控制台应用程序或 Windows 窗体应用程序)中,ASP.NET 缓存可能无法正常工

  • ASP.NET数据库缓存依赖实例分析

    本文实例讲述了ASP.NET数据库缓存依赖,分享给大家供大家参考.具体如下: 一般在ASP.NET中,Cache类最酷的特点是它能根据各种依赖来良好的控制自己的行为.以文件为基础的依赖是最有用的,文件依赖项是通过使用 Cache.Insert 并提供引用文件的 CacheDependency 对象添加的 复制代码 代码如下: Cache.Insert("MyData", Source, new CacheDependency(Server.MapPath("authors.x

  • SQL Server 高速缓存依赖分析

    一,使数据库支持SQL高速缓存依赖性. 二,使表支持SQL高速缓存依赖性. 三,在ASP.NET应用程序的web.config文件中包含SQL连接字符串. 四,以如下方式利用SQL高速缓存依赖性:      1)在代码中编程创建一个SqlCacheDependency对象.      2)给OutputCache指令添加SqlCacheDependency属性.      3)通过Response.AddCacheDependency给Response对象添加一SqlCacheDependenc

  • 开启SQLSERVER数据库缓存依赖优化网站性能

    很多时候,我们服务器的性能瓶颈会是在查询数据库的时候,所以对数据库的缓存非常重要,那么有没有一种方法,可以实现SQL SERVER数据库的缓存,当数据表没有更新时,就从缓存中读取,当有更新的时候,才从数据表中读取呢,答案是肯定的,这样的话我们对一些常用的基础数据表就可以缓存起来,比如做新闻系统的新闻类别等,每次就不需要从数据库中读取了,加快网站的访问速度. 那么如何开启SQLSERVER数据库缓存依赖,方法如下: 第一步:修改Web.Config的<system.web>节的配置,代码如下,让

  • 深入分析缓存依赖中cachedependency对象及周边小讲

    最近正在学缓存依赖,现把一些学习资料整理如下:缓存依赖主要提供以下功能:1.SQL 缓存依赖项可用于应用程序缓存和页输出缓存.2.可在 SQL Server 7.0 及更高版本中使用 SQL 缓存依赖项.3.可以在网络园(一台服务器上存在多个处理器)或网络场(多台服务器运行同一应用程序)中使用 SQL 缓存依赖项.4.与 SQL 缓存依赖项关联的数据库操作比较简单,因此不会给服务器带来很高的处理成本. 现在把与缓存依赖相关的对象集合如下,并对差异性进行了一定程度的分析--缓存依赖主要由3个核心类

  • asp.net连接数据库读取数据示例分享

    webconfig配置: 复制代码 代码如下: <connectionStrings>  <add name="MSSQL" connectionString="Data Source=localhost;Initial Catalog=test;User ID=sa;password=sa;" providerName="System.Data.SqlClient"/></connectionStrings>

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

    Key-Value缓存有很多,用的较多的是memcache.redis,他们都是以独立服务的形式运行,在工作中有时需要嵌入一个本地的key-value缓存,当然已经有LevelDb等,但感觉还是太重量级了. 本文实现了一种超级轻量的缓存, 1.实现代码仅仅需要400行: 2.性能高效,value长度在1K时测试速度在每秒200万左右 3.缓存是映射到文件中的,所以没有malloc.free的开销,以及带来的内存泄露.内存碎片等: 4.如果服务挂掉了,重启后缓存内容继续存在: 5.如果把缓存映射到

  • ssm框架上传图片保存到本地和数据库示例

    本文介绍了ssm框架上传图片保存到本地和数据库示例,主要使用了Spring+SpringMVC+MyBatis框架,实现了ssm框架上传图片的实例,具体如下: 1.前台部分 <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <!DOCTYPE html> <html> <head&g

  • Go语言集成mysql驱动、调用数据库、查询数据操作示例

    本文实例讲述了Go语言集成mysql驱动.调用数据库.查询数据操作.分享给大家供大家参考,具体如下: 1.安装第三方mysql驱动包 go get -u github.com/go-sql-driver/mysql 2.连接数据库基本代码 复制代码 代码如下: package main import (         _"github.com/go-sql-driver/mysql"  // 注意前面的下划线_, 这种方式引入包只执行包的初始化函数         "dat

  • python读取word文档,插入mysql数据库的示例代码

    表格内容如下: 1.实现批量导入word文档,取文档标题中的数字作为编号 2.除取上面打钩的内容需要匹配出来入库入库,其他内容全部直接入库mysql # wuyanfeng # -*- coding:utf-8 -*- # 读取docx中的文本代码示例 import docx import pymysql import re import os # 创建数据库链接 conn = pymysql.connect( host='rm-bp1vu5d84dg12c6d59o.mysql.rds.ali

  • Vue+mui实现图片的本地缓存示例代码

    下面一段代码给大家分享基于Vue+mui实现图片的本地缓存,具体代码如下所示: const menu = { state: { products: {}, GLOBAL_CONFIG:GLOBAL_CONFIG['GLOBAL_CONFIG'] }, mutations: { get_product: function (state, products) { //商品列表 state.products = products; for(let i = 0; i < state.products.l

  • Python操作MySQL数据库的示例代码

    1. MySQL Connector 1.1 创建连接 import mysql.connector config={ "host":"localhost","port":"3306", "user":"root","password":"password", "database":"demo" } con=

  • 如何把本地mysql迁移到服务器数据库

    我们可以使用linux的scp命令(scp无法在windows使用),加上mysql自带的mysqldump,能很快的完成数据库的迁移 将本地的数据库(music_db)导出为sql文件(music_db.sql) mysqldump -uroot -p music_db > music_db.sql 用scp命令将sql文件发送到服务器 scp music_db.sql 远程登录账号@服务器ip:服务器目录/music_db.sql ssh登录服务器 ssh 远程登录账号@远程ip 在服务器上

  • MySQL+Redis缓存+Gearman共同构建数据库缓存的方法

    目录 前言 一.前端搭建 1.Nginx部署 2.php部署安装以及模块安装 二.后端部署 1.MySQL部署 2.Redis作为缓存的部署以及安装 三.germand分布式缓存位置部署 1.gearman原理 2.C端部署 3.S端部署 总结 前言 一.前端搭建 1.Nginx部署 安装部署Nginx yum install unzip openssl-devel pcre-devel gcc make -y tar -zxf nginx-1.22.0.tar.gz ./configure -

  • MySQL和Redis实现二级缓存的方法详解

    redis简介 Redis 是完全开源免费的,遵守BSD协议,是一个高性能的key-value数据库 Redis 与其他 key - value 缓存产品有以下三个特点: Redis支持数据的持久化,可以将内存中的数据保存在磁盘中,重启的时候可以再次加载进行使用 Redis不仅仅支持简单的key-value类型的数据,同时还提供list,set,zset,hash等数据结构的存储 Redis支持数据的备份,即master-slave模式的数据备份 优势 性能极高 - Redis能读的速度是110

  • 浅谈数据库缓存最终一致性的四种方案

    背景 缓存是软件开发中一个非常有用的概念,数据库缓存更是在项目中必然会遇到的场景.而缓存一致性的保证,更是在面试中被反复问到,这里进行一下总结,针对不同的要求,选择恰到好处的一致性方案. 缓存是什么 存储的速度是有区别的.缓存就是把低速存储的结果,临时保存在高速存储的技术. 如图所示,金字塔更上面的存储,可以作为下面存储的缓存. 我们本次的讨论,主要针对数据库缓存场景,将以redis作为mysql的缓存为案例来进行. 为什么需要缓存 存储如mysql通常支持完整的ACID特性,因为可靠性,持久性

随机推荐