分布式KV存储的实现

已于 2025-04-08 11:56:54 修改
阅读量173 收藏
点赞数 5
文章标签： 分布式 KV 数据结构
于 2025-04-01 21:00:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_71694051/article/details/146922529
版权

目录

一、KV 存储的核心设计哲学

1. 键值对的本质

2. 存储引擎的黑魔法

3. 分布式扩展的奥秘

二、KV 存储的核心模块

1.reactor/ntyco/io_uring

2.协议层kv-store

3.数据结构rbtree/array/hash

4.内存池mp_pool

5.测试用例test_case

三、部分源码细究

一、KV 存储的核心设计哲学

1. 键值对的本质

KV 存储的核心是将数据抽象为键值对（Key-Value Pair）。键作为唯一标识符，值则承载任意格式的数据。这种设计摒弃了传统关系型数据库的复杂表结构，将数据存储简化为 “键→值” 的映射，从而实现了 O (1) 级别的读写效率。

2. 存储引擎的黑魔法

主流 KV 存储（如 Redis、RocksDB）采用哈希表或跳表等数据结构，结合内存与磁盘分层存储：

内存型（如 Redis）：将数据常驻内存，通过异步持久化保证可靠性。

持久化型（如 LevelDB）：数据写入磁盘，利用 LSM-Tree 结构优化读写性能。

3. 分布式扩展的奥秘

分布式 KV 存储（如 DynamoDB）通过一致性哈希、分片（Sharding）和复制（Replication）实现水平扩展：

分片：将数据分散到多个节点，避免单点瓶颈。

复制：每个分片保留多个副本，确保高可用性。

二、KV 存储的核心模块

1.reactor/ntyco/io_uring

2.协议层kv-store

3.数据结构rbtree/array/hash

4.内存池mp_pool

5.测试用例test_case

三、部分源码细究


#include"kvstore.h"

#define KVSTORE_MAX_TOKEN 128

const char*commands[]={
    "SET","GET","DEL","MOD","COUNT",
    "RSET","RGET","RDEL","RMOD","RCOUNT",
    "HSET","HGET","HDEL","HMOD","HCOUNT",
    
};

enum{
    KV_CMD_START= 0,
    KV_CMD_SET=KV_CMD_START,
    KV_CMD_GET,
    KV_CMD_DEL,
    KV_CMD_MOD,
    KV_CMD_COUNT,

    KV_CMD_RSET,
    KV_CMD_RGET,
    KV_CMD_RDEL,
    KV_CMD_RMOD,
    KV_CMD_RCOUNT,

    KV_CMD_HSET,
    KV_CMD_HGET,
    KV_CMD_HDEL,
    KV_CMD_HMOD,
    KV_CMD_HCOUNT,
    KV_CMD_SIZE,
};


void  *kvstore_malloc(size_t size){
    #if ENABLE_MEM_POOL
    char *ptr = mp_allock(&M);
    #else
    return malloc(size);
    #endif
}

void kvstore_free(void *ptr){
    #if ENABLE_MEM_POOL

    #else
    return free(ptr);
    #endif
}

#if ENABLE_RBTREE_KVENGINE
int kvstore_rbtree_set(char *key, char *value){
    return kvs_rbtree_set(&Tree, key, value);
}
char* kvstore_rbtree_get( char *key){
    return kvs_rbtree_get(&Tree,key);

}
int kvstore_rbtree_delete( char *key){
    return kvs_rbtree_delete(&Tree,key);
}
int kvstore_rbtree_modify( char *key, char *value){
    return kvs_rbtree_modify(&Tree,key,value);
}

int kvstore_rbtree_count(){
    return kvs_rbtree_count(&Tree);
}
#endif


#if ENABLE_ARRAY_KVENGINE
int kvstore_array_set(char *key,char *value){
    return kvs_array_set(&Array,key,value);
}

char *kvstore_array_get(char*key){
    return kvs_array_get(&Array,key);
}

int kvstore_array_del(char*key){
   return kvs_array_del(&Array,key);
}

int kvstore_array_mod(char*key,char*value){
    return kvs_array_mod(&Array,key,value);
}

int kvstore_array_count(){
    return kvs_array_count(&Array);
}

#endif


#if ENABLE_HASH_KVENGINE
int kvstore_hash_set(char *key,char *value){
    return kvs_hash_set(&Hash,key,value);
}

char *kvstore_hash_get(char*key){
    return kvs_hash_get(&Hash,key);
}

int kvstore_hash_del(char*key){
   return kvs_hash_delete(&Hash,key);
}

int kvstore_hash_mod(char*key,char*value){
    return kvs_hash_modify(&Hash,key,value);
}

int kvstore_hash_count(){
    return kvs_hash_count(&Hash);
}

#endif


int kvstore_split_token(char*msg,char**tokens){
    if(msg==NULL || tokens==NULL) return -1;

    int idx = 0;
    char *token = strtok(msg," ");
    while(token!=NULL){
        tokens[idx++]=token;
        token = strtok(NULL," ");
    }

    return idx;
}

int kvstore_parser_protocol(struct conn_item*item,char**tokens,int count){
    if(item==NULL||tokens[0]==NULL||count==0) return  -1;
    int cmd = KV_CMD_START;
    for(cmd=KV_CMD_START;cmd<KV_CMD_SIZE;cmd++){
        if(strcmp(commands[cmd],tokens[0])==0) break;
    }


    char*msg=item->wbuffer;
    char*key = tokens[1];
    char*value =tokens[2];
    
    memset(msg,0,BUFFER_LENGTH);

    switch(cmd){
        case KV_CMD_SET:{
        int res=kvstore_array_set(key,value);
        if(res==0){
            snprintf(msg,BUFFER_LENGTH,"SUCCESS");
        }else{
            snprintf(msg,BUFFER_LENGTH,"FAILED");
        }
        break;
    }

        case KV_CMD_GET:{
        char *values=kvstore_array_get(key);
        if(values!=NULL){
            snprintf(msg,BUFFER_LENGTH,"%s",values);
        }else{
            snprintf(msg,BUFFER_LENGTH,"NO EXIST");
        }

        //printf("get:%s\n",values);
        break;
    }

        case KV_CMD_DEL:{
        //printf("del\n");
        int res =kvstore_array_del(key);
        if(res<0){
            snprintf(msg,BUFFER_LENGTH,"%s","ERROR");
        }else if(res==0){
            snprintf(msg,BUFFER_LENGTH,"%s","SUCCESS");
        }else{
            snprintf(msg,BUFFER_LENGTH,"NO EXIST");
        }
        break;
    }

        case KV_CMD_MOD:{
        //printf("mod\n");
        int res =kvstore_array_mod(key,value);
        if(res<0){
            snprintf(msg,BUFFER_LENGTH,"%s","ERROR");
        }else if(res==0){
            snprintf(msg,BUFFER_LENGTH,"%s","SUCCESS");
        }else{
            snprintf(msg,BUFFER_LENGTH,"NO EXIST");
        }
        break;
    }
      case KV_CMD_COUNT:{
        int count =kvs_array_count(&Array);
        if(count<0){
            snprintf(msg,BUFFER_LENGTH,"%s","ERROR");
        }else{
            snprintf(msg,BUFFER_LENGTH,"%d",count);
        }
        break;
      }

      case KV_CMD_RSET:{
        int res=kvstore_rbtree_set(key,value);
        if(res==0){
            snprintf(msg,BUFFER_LENGTH,"SUCCESS");
        }else{
            snprintf(msg,BUFFER_LENGTH,"FAILED");
        }
        break;
      }

      case KV_CMD_RGET:{
        char*values=kvstore_rbtree_get(key);
        if(values!=NULL){
            snprintf(msg,BUFFER_LENGTH,"%s",values);
        }else{
            snprintf(msg,BUFFER_LENGTH,"NO EXIST");
        }
        break;
      }

      case KV_CMD_RDEL:{
        int res =kvstore_rbtree_delete(key);
        if(res<0){
            snprintf(msg,BUFFER_LENGTH,"%s","ERROR");
        }else if(res==0){
            snprintf(msg,BUFFER_LENGTH,"%s","SUCCESS");
        }else{
            snprintf(msg,BUFFER_LENGTH,"NO EXIST");
        }
        break;
      }

      case KV_CMD_RMOD:{
        int res=kvstore_rbtree_modify(key,value);
        if(res<0){
            snprintf(msg,BUFFER_LENGTH,"%s","ERROR");
        }else if(res==0){
            snprintf(msg,BUFFER_LENGTH,"%s","SUCCESS");
        }else{
            snprintf(msg,BUFFER_LENGTH,"NO EXIST");
        }
        break;
      }

      case KV_CMD_RCOUNT:{
        int count =kvstore_rbtree_count();
        if(count<0){
            snprintf(msg,BUFFER_LENGTH,"%s","ERROR");
        }else{
            snprintf(msg,BUFFER_LENGTH,"%d",count);
        }
        break;
      }


      case KV_CMD_HSET:{
        int res=kvstore_hash_set(key,value);
        if(res==0){
            snprintf(msg,BUFFER_LENGTH,"SUCCESS");
        }else{
            snprintf(msg,BUFFER_LENGTH,"FAILED");
        }
        break;
      }

      case KV_CMD_HGET:{
        char*values=kvstore_hash_get(key);
        if(values!=NULL){
            snprintf(msg,BUFFER_LENGTH,"%s",values);
        }else{
            snprintf(msg,BUFFER_LENGTH,"NO EXIST");
        }
        break;
      }

      case KV_CMD_HDEL:{
        int res =kvstore_hash_del(key);
        if(res<0){
            snprintf(msg,BUFFER_LENGTH,"%s","ERROR");
        }else if(res==0){
            snprintf(msg,BUFFER_LENGTH,"%s","SUCCESS");
        }else{
            snprintf(msg,BUFFER_LENGTH,"NO EXIST");
        }
        break;
      }

      case KV_CMD_HMOD:{
        int res=kvstore_hash_mod(key,value);
        if(res<0){
            snprintf(msg,BUFFER_LENGTH,"%s","ERROR");
        }else if(res==0){
            snprintf(msg,BUFFER_LENGTH,"%s","SUCCESS");
        }else{
            snprintf(msg,BUFFER_LENGTH,"NO EXIST");
        }
        break;
    }
        

        case KV_CMD_HCOUNT:{
            int count =kvstore_hash_count();
            if(count<0){
                snprintf(msg,BUFFER_LENGTH,"%s","ERROR");
            }else{
                snprintf(msg,BUFFER_LENGTH,"%d",count);
            }
        
        break;
      }

        default:{
        //printf("cmd%s\n",commands[cmd]);
        assert(0);
        }
    }
    
}

int kvstore_requese(struct conn_item*item){
    //printf("recv: %s\n",item->rbuffer);

    char * msg = item->rbuffer;
    char *tockens[KVSTORE_MAX_TOKEN];

    int count = kvstore_split_token(msg,tockens);

    int idx;
    for(idx =0;idx<count;idx++){
        //printf("idx:%s\n",tockens[idx]);
    }

    kvstore_parser_protocol(item,tockens,count);

    return 0; 
}

int init_kvengine(void){
    #if  ENABLE_ARRAY_KVENGINE
    kvstore_array_create(&Array);
    #endif

    #if ENABLE_RBTREE_KVENGINE
    kvstore_rbtree_create(&Tree);
    #endif

    #if ENABLE_HASH_KVENGINE
    kvstore_hash_create(&Hash);
    #endif
}

int exit_kvengine(void){
    #if  ENABLE_ARRAY_KVENGINE
    kvstore_array_destory(&Array);
    #endif

    #if ENABLE_RBTREE_KVENGINE
    kvstore_rbtree_destory(&Tree);
    #endif

    #if ENABLE_HASH_KVENGINE
    kvstore_hash_destory(&Hash);
    #endif
}

int init_pool(void){
    #if ENABLE_MEM_POOL
    mp_init(&M,4096);
    #endif
}

int destory_pool(void){
    #if ENABLE_MEM_POOL
    mp_dest(&M);
    #endif
}


int main(){

    init_kvengine();
    init_pool();

#if (ENABLE_NETWORK_SELECT==NETWORK_EPOLL)
     epoll_entry();
#elif(ENABLE_NETWORK_SELECT==NETWORK_NTYCO)
     ntyco_enrty();
#elif(ENABLE_NETWORK_SELECT==NETWORK_IOURING)

#endif

    exit_kvengine();
    destory_pool();
    
}

这些是对外用户封装的接口

①设置命令对应

②开辟内存和释放内存的接口 可以兼容内存池

③对接红黑叔 数组 哈希的接口

④分割函数strtok的使用

⑤制定协议的接口

⑥接收数据的接口

⑦选择数据结构的接口

⑧释放资源的接口

⑨定义和销毁内存池的接口

⑩main函数一切的起点

内存池的介绍和复习

#include<stdlib.h>
#include<stdio.h>
#include"kvstore.h"
#define MEM_PAGE_SIZE 4096

typedef struct mempool_s{
	int block_size;
	int free_count;

	char*free_ptr;
	char*mem;
}mempool_t;

//内存池的初始化
int mp_init(mempool_t*m,int size){
	if(m==NULL) return -1;
	if(size<16) size=16;
	
	m->block_size=size;//固定大小的内存块
	m->mem=(char*)malloc(MEM_PAGE_SIZE);
	if(m->mem==NULL) return -2;

	m->free_ptr=m->mem;
	m->free_count=MEM_PAGE_SIZE/size;

	int i =0;
	char*ptr= m->free_ptr;
	for(i;i<m->free_count;i++){
		*(char**)ptr=ptr+size;//☆
		ptr+=size;
	}
	*(char**)ptr=NULL;
}

//内存池的销毁
void mp_dest(mempool_t*m){
	if(m==NULL||m->mem==NULL) return;
	free(m->mem);
}

//为内存块分配内存
void * mp_allock(mempool_t*m){
	if(m==NULL||m->free_count==0) return NULL;
	void*ptr =m->free_ptr;//ptr指向一块空闲的内存

	m->free_ptr=*(char**)ptr;//m->free_ptr指向下一块空闲的内存 ☆
	m->free_count--;
	
	return ptr;
}

//为内存块释放内存
void mp_free(mempool_t*m,void*ptr){
	*(char**)ptr=m->free_ptr;
	m->free_ptr=(char*)ptr;
	m->free_count++;
}

mempool_t M;


#if 0
int main(){
	mempool_t m;
    mp_init(&m,32);
	

	void *p1 =mp_allock(&m);
	printf("1:mp_alloc:%p\n",p1);

	void *p2 =mp_allock(&m);
	printf("2:mp_alloc:%p\n",p2);

	void *p3 =mp_allock(&m);
	printf("3:mp_alloc:%p\n",p3);

	void *p4 =mp_allock(&m);
	printf("4:mp_alloc:%p\n",p4);

	mp_free(&m,p2);

	void *p5 =mp_allock(&m);
	printf("5:mp_alloc:%p\n",p5);

}

#endif

//对内存块的管理
//1.避免频繁分配
//2.长期运行出现的内存碎片

①内存池结构体

block_size

内存块的大小

free_count

空闲的内存块

free_ptr

指向空闲内存块的指针

mem

开辟内存页的大小

②内存池的初始化

内存块大小设置为size

开辟的内存页大小设置为MEM_PAGE_SIZE

空闲指针free_ptr 指向开头

空闲内存块的数量为m->free_count=MEM_PAGE_SIZE/size

通过for循环生成一串链表

③内存池的销毁

④为内存块分配内存

⑤为内存块释放内存

分布式kv存储
weixin_45620740的博客
12-11 1708
注册中心作为服务治理框架的核心，负责所有服务的注册，服务之间的调用也都通过注册中心来请求服务发现。注册中心重要性不言而喻，一旦宕机，全部的服务都会出现问题，所以我们需要多个注册中心组成集群来提供服务。 本项目中，通过 raft 分布式共识算法，简单实现了分布式一致性的 KV 存储系统，对接口进行了封装，并且提供了 HTTP 接口和 RPC 接口。为以后注册中心集群的实现打下了基础。
KV存储
sym19862006的专栏
12-05 596
KV-存储 之 Hash算法 http://www.cesclub.com/bw/jishuzhongxin/bianchengyuyan/2011/0924/10415.html 生活生计不是局限于人类寻求本身的实际目标所进行的日常步履，而是显示了人类参加到一种宇宙韵律中来，这种韵律以形形的体式格式证实其自身的存在。生活生计中你应当碰到如许的工作: 你要去近邻班级拿本书...
kv存储---网络
最新发布
weixin_51348443的博客
04-27 558
1.概念：KV存储（Key-Value存储）是一种基于键值对（Key-Value Pair）的数据存储模型，通过唯一键（Key）直接关联值（Value）。2.
分布式 KV 存储系统 Cellar 演进之路--美团.pdf
05-22
分布式 KV 存储系统 Cellar 演进之路--美团.pdf
使用开源技术构建有赞分布式 KV 存储服务
weixin_34080951的博客
08-20 804
背景 在有赞早期的时候，当时只有 MySQL 做存储，codis 做缓存，随着业务发展，某些业务数据用 MySQL 不太合适， 而 codis 由于当缓存用， 并不适合做存储系统， 因此， 急需一款高性能的 NoSQL 产品做补充。考虑到当时运维和开发人员都非常少， 我们需要一个能快速投入使用， 又不需要太多维护工作的开源产品。 当时对比了几个开源产品， 最终选择了 aerospike 作为我们的...
KV存储系统
weixin_34228617的博客
07-30 1748
现在的KV存储系统都是分布式的，首先介绍Zookeeper——针对大型分布式系统的高可靠的协调系统。 开发分布式系统是件很困难的事情，其中的困难主要体现在分布式系统的“部分失败”。“部分失败”是指信息在网络的两个节点之间传送时候，如果网络出了故障，发送者无法知道接收者是否收到了这个信息，而且这种故障的原因很复杂，接收者可能在出现网络错误之前已经收到了信息，也可能没有收到，又或接收者的进程死掉了。...
KVBase分布式存储设计与实现
m0_60259116的博客
06-05 1021
KVBase分布式存储设计与实现
Zeppelin：一个分布式KV存储平台之存储节点
cizhuo6814的博客
11-01 226
通过上一篇Zeppelin：一个分布式KV存储平台之概述的介绍，相信读者已经对Zeppelin有了大致的了解，这篇就将详细介绍其中的存储节点集群（Node Server）。存储节点负责最终的数据存储，每个Node Server会...
基于Raft的简易分布式KV存储系统源码+项目使用说明.zip
07-19
基于Raft的简易分布式KV存储系统源码+项目使用说明.zip 该项目是个人毕设项目，答辩评审分达到95分，代码都经过调试测试，确保可以运行！欢迎下载使用，可用于小白学习、进阶。 该资源主要针对计算机、通信、人工...
一款Java分布式KV存储系统源码.zip
05-20
本篇文章将深入剖析一款基于Java实现的分布式KV存储系统的源码，帮助开发者理解和掌握其中的核心技术与设计思想。 首先，我们需要理解KV存储的基本概念。KV存储是一种数据存储模型，其中每个数据项由一个唯一的键...
(源码)基于C++的分布式KV存储与网络库实现.zip
04-13
# 基于C++的分布式KV存储与网络库实现 ## 项目简介 本项目旨在通过实现分布式KV存储系统和网络库，深入学习和应用C++编程语言在分布式系统和网络编程中的核心技术。项目分为两个主要部分分布式KV存储系统（SRAFT）...
赵森-腾讯自研分布式KV存储之路.pdf
01-14
自研分布式内存引擎的优点：精准LRU队列，非近似算法。写操作触发过期，同时主动轮询，主动回收资源。 更高的设备利用率、非对称副本集、功能兼容
基于Raft算法的分布式KV存储系统设计源码
10-11
基于Raft算法的分布式KV存储系统是此类系统的一个具体实现。KV存储系统，即键值存储系统，是一种数据结构的存储系统，它使用键值对作为数据组织的方式。这种系统的特点是能够快速地对数据进行检索和更新操作。 本...
分布式K/V存储方案-Tair
qq_33696779的博客
07-18 1528
一、Tair介绍 Tair是由淘宝网自主开发的Key/Value结构数据存储系统，它默认支持基于内存和文件的两种存储方式，分别和我们通常所说的缓存和持久化存储对应。非持久化的 tair 可以看成是一个分布式缓存. 持久化的 tair 将数据存放于磁盘中。为了解决磁盘损坏导致数据丢失, tair 可以配置数据的备份数目, tair 自动将一份数据的不同备份放到不同的主机上；当有主...
精品C++项目推荐：分布式kv存储系统
代码随想录
12-10 2320
项目代码直接开源到Github：https://github.com/youngyangyang04/KVstorageBaseRaft-cpp欢迎去star，fork！在当今大规模分布式系统的背景下，需要可靠、高可用性的分布式数据存储系统。传统的集中式数据库在面对大规模数据和高并发访问时可能面临单点故障和性能瓶颈的问题。为了解决这些问题，本项目致力于构建一种基于Raft一致性算法的分布式键值存储数据库，以确保数据的一致性、可用性和分区容错性。学习了Raft算法之后手动实现，并基于此搭建了一个k-v存储的分
KinsDB：快手分布式KV存储底座的演进与技术细节
ITPUBD的博客
03-18 340
KinsDB的架构设计充分考虑了分布式系统的特点，包括多模支撑、高内聚、高可用、跨AZ部署等。KinsDB是快手内部自研的存储-计算分离架构下的分布式KV存储底座，具有低延迟、高吞吐的特性。它不仅支持KV接口，还向上支撑了SQL、宽表、图计算等多种计算引擎，为快手内部的核心业务提供了强有力的数据存储支持。未来，KinsDB将继续优化性能，提升系统的稳定性和可扩展性，以应对更加复杂和多样化的业务需求。KinsDB在快手内部得到了广泛的应用，支撑了包括KV、SQL、宽表、图计算等多种场景。
300行实现的完整分布式存储系统MatrixKV初体验
异阁的专栏
07-22 356
300行实现的完整分布式存储系统MatrixKV初体验
使用Consul的KV存储管理分布式应用的配置（第五部分）
weixin_40726747的博客
08-15 1014
在前面的四部分中，我们已经深入探讨了Consul的服务发现、健康检查、分布式部署，以及如何与Traefik集成构建服务网格。在构建和管理分布式系统时，配置管理是一个至关重要的环节。传统的配置管理方法往往难以应对分布式环境的复杂性，而Consul的KV（键值）存储为我们提供了一种灵活、可靠的配置管理方式。本部分将详细介绍如何使用Consul的KV存储来管理分布式应用的配置，确保系统的配置数据始终保持一致性、可扩展性和高可用性。
【KV存储（1）】KV存储总体设计及简介
Morso的博客
12-17 1423
本文将引入KV存储，并对其架构设计进行分析。
Go语言实现兼容Redis的分布式KV存储系统
3. 分布式KV存储：分布式KV存储是一种网络服务，它将数据存储在多台计算机上，通过网络互相通信以提供数据存储和检索功能。分布式存储的优势在于通过数据分片来提高系统容量和性能，以及实现容错和高可用性。 4. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值