一致性hash应用-分库分表

原创 已于 2025-04-02 22:09:45 修改 · 1k 阅读 · 17 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#哈希算法 #算法 #分库分表

于 2025-03-31 22:16:37 首次发布
😊 @ 作者： 一恍过去
🎊 @ 社区： Java技术栈交流
🎉 @ 主题： 一致性hash应用-分库分表
⏱️ @ 创作时间： 2025年03月31日

目录

前言

一致性哈希(Consistent Hashing)是分布式系统中常用的数据分片技术，将数据分布到一个哈希环上，，它能在节点增减时最小化数据迁移量，哈希环的大小为2的32次方-1；

通过这种一致性哈希的分库分表方案，可以实现数据的均匀分布和平滑扩容，对于水平扩展的业务场景；在实现扩容，会伴随数据的迁移，通过一致性Hash，环实现对旧数据影响最小。

核心概念

  1. 哈希环：将哈希空间组织成一个环形结构。
  2. 虚拟节点：每个物理节点对应多个虚拟节点，实现更均匀的分布。
  3. 数据路由：数据键的哈希值在环上顺时针找到的第一个节点即为存储节点。
  4. 扩容处理：新增节点时只影响相邻节点的数据，相比于取模方式，影响范围小。

路由&扩容原理

1、计算节点的hash值，比如存在node1、node2、node3，分别在服务器A/B/C上，并且每个节点都有自己的hash值，如下图分布
在这里插入图片描述

2、 数据在进行存储时，计算数据key的hash值，然后顺时针找到的第一节点所属的hash值，那么数据就存储到该节点上，如下图：
在这里插入图片描述

3、数据的扩容，影响范围最小化，比如新增了一个nodeX，并且nodeX节点的Hash值比nodeC的hash值，此时有一个数据C顺时针的第一个节点就是nodeX了，但是数据A、和数据B并不会收到影响；对于扩容后我们只需要将nodeC的数据迁移到nodeX即可，其他节点不用动
在这里插入图片描述

资源倾斜问题

比如：

我们现在有三个节点(nodeA、nodeB、nodeC)，这三个节点分别在Hash环的不同位置，并且数据Key分别为：a、b、c、d、e、f；

在进行hash计算时，可能出现 a、b、c、d可能在nodeA中，e在nodeB中、f在nodeC中，这就出现了资源倾斜；为了尽可能的实现平均分别，引入了虚拟节点；

设定每个节点都有100个虚拟接口，虚拟节点分别为：nodeA001…nodeA002…nodeA100、nodeB001…nodeB002…nodeB100、nodeC001…nodeC002…nodeC100；引入虚拟节点后此时三个真实节点实际在hash环上就有300个节点了，提高了节点的平均分布率，可以更好的实现数据均分到不同的节点上。

如图所示，节点A在Hash环上有A1和A2等虚拟节点，只要在A1和A2后面的数据key，都会存入到服务器A中；
在这里插入图片描述

代码实现

基础实现

引入依赖：

<dependency>
  <groupId>com.google.guava</groupId>
  <artifactId>guava</artifactId>
  <version>33.0.0-jre</version>
</dependency>

hash计算工具类：

import com.google.common.hash.Hashing;

import java.nio.charset.StandardCharsets;
import java.util.*;
public class ShardingRouterComponent {

    // 虚拟节点到物理节点的映射
    private final TreeMap<Long, String> VIRTUAL_NODE_MAP = new TreeMap<>();
    
    public ShardingRouterComponent(List<String> physicalShards) {
        initVirtualNodes(physicalShards);
    }
    
   	private void initVirtualNodes(List<String> physicalShards) {
        for (String shard : physicalShards) {
            // addShard(shard);
            long hash = hash(shard);
            VIRTUAL_NODE_MAP.put(hash, shard);
        }
    }
    
    public String routeShard(Long key) {
        if (VIRTUAL_NODE_MAP.isEmpty()) {
            throw new RuntimeException("No shards available");
        }
        long hash = hash(key.toString());
        // 找到第一个大于等于该哈希值的节点
        SortedMap<Long, String> tail = VIRTUAL_NODE_MAP.tailMap(hash);
        if (tail.isEmpty()) {
            return VIRTUAL_NODE_MAP.firstEntry().getValue();
        }
        return tail.get(tail.firstKey());
    }
    
   	public long hash(String key) {
        return Hashing.murmur3_128()
                .hashString(key, StandardCharsets.UTF_8)
                .asLong();
    }
}

验证

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class MainTest {
        public static void main(String[] args) {
        // 创建4个节点
        List<String> list = new ArrayList<>();
        for (int i = 0; i <= 4; i++) {
            String s = "node_" + i;
            list.add(s);
        }
        ShardingRouterComponent routerComponent = new ShardingRouterComponent(list);
        System.out.println(routerComponent.getAllPhysicalShards());
        Map<String, List<Long>> m1 = new HashMap<>();
        for (long a = 1; a <= 30; a++) {
            String shard = routerComponent.routeShard(a);
            System.out.println("key=" + a + " -> shard=" + shard);
            List<Long> longList = m1.get(shard);
            if (longList == null) {
                longList = new ArrayList<>();
                longList.add(a);
                m1.put(shard, longList);
            } else {
                longList.add(a);
            }
        }
        System.out.println(m1);
    }
}

运行上面代码后，可以看到不同的key进入了不同的node节点中，但是存在一个问题：有点节点数据较少，有的节点数据较多，这就是资源倾斜了；要处理资源倾斜，我们需要增加一个虚拟节点来处理；
在这里插入图片描述

资源倾斜问题

增加虚拟节点：

修改ShardingRouterComponent类来实现虚拟节点的功能，所谓虚拟节点就是我们虚构的节点，不存在真实的服务器，我们将使用真实节点+'#VN'+虚拟数的方式拼接一个key，并且将该key的hash值与真实节点进行绑定；

完整代码如下：

import com.google.common.hash.Hashing;

import java.nio.charset.StandardCharsets;
import java.util.*;

public class ShardingRouterComponent {

    // 虚拟节点到物理节点的映射
    private final TreeMap<Long, String> VIRTUAL_NODE_MAP = new TreeMap<>();

    // 每个物理节点对应的虚拟节点数
    private final int VIRTUAL_NODE_SHARD_NUM;

    public ShardingRouterComponent(List<String> physicalShards, int virtualNodePerShard) {
        this.VIRTUAL_NODE_SHARD_NUM = virtualNodePerShard;
        initVirtualNodes(physicalShards);
    }

    private void initVirtualNodes(List<String> physicalShards) {
        for (String shard : physicalShards) {
            addShard(shard);
        }
    }

    public String routeShard(Long key) {
        if (VIRTUAL_NODE_MAP.isEmpty()) {
            throw new RuntimeException("No shards available");
        }
        long hash = hash(key.toString());
        // 找到第一个大于等于该哈希值的节点
        SortedMap<Long, String> tail = VIRTUAL_NODE_MAP.tailMap(hash);
        if (tail.isEmpty()) {
            return VIRTUAL_NODE_MAP.firstEntry().getValue();
        }
        return tail.get(tail.firstKey());
    }

    public long hash(String key) {
        return Hashing.murmur3_128()
                .hashString(key, StandardCharsets.UTF_8)
                .asLong();
    }


    public void addShard(String shard) {
        for (int i = 0; i < VIRTUAL_NODE_SHARD_NUM; i++) {
            long hash = hash(shard + "#VN#" + i);
            VIRTUAL_NODE_MAP.put(hash, shard);
        }
    }

}

验证

我们现在有4个物理节点(node0...node3)，并且为每个节点，都设置100个虚拟节点，验证代码如下：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class MainTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i <= 4; i++) {
            String s = "node_" + i;
            list.add(s);
        }
        ShardingRouterComponent routerComponent = new ShardingRouterComponent(list, 10);
        System.out.println(routerComponent.getAllPhysicalShards());
        Map<String, List<Long>> m1 = new HashMap<>();
        for (long a = 1; a <= 30; a++) {
            String shard = routerComponent.routeShard(a);
            System.out.println("key=" + a + " -> shard=" + shard);
            List<Long> longList = m1.get(shard);
            if (longList == null) {
                longList = new ArrayList<>();
                longList.add(a);
                m1.put(shard, longList);
            } else {
                longList.add(a);
            }
        }
        System.out.println(m1);

    }
}

运行上面代码后，可以看到数据相对较均匀
在这里插入图片描述

整合Spring使用(以分库分表为例)

一致性hash工具

import com.google.common.hash.Hashing;

import java.nio.charset.StandardCharsets;
import java.util.*;

public class ShardingRouterComponent {

    // 虚拟节点到物理节点的映射
    private final TreeMap<Long, String> VIRTUAL_NODE_MAP = new TreeMap<>();

    // 每个物理节点对应的虚拟节点数
    private final int VIRTUAL_NODE_SHARD_NUM;

    public ShardingRouterComponent(List<String> physicalShards, int virtualNodePerShard) {
        this.VIRTUAL_NODE_SHARD_NUM = virtualNodePerShard;
        initVirtualNodes(physicalShards);
    }

    private void initVirtualNodes(List<String> physicalShards) {
        for (String shard : physicalShards) {
            addShard(shard);
        }
    }

    public String routeShard(Long key) {
        if (VIRTUAL_NODE_MAP.isEmpty()) {
            throw new RuntimeException("No shards available");
        }
        long hash = hash(key.toString());
        // 找到第一个大于等于该哈希值的节点
        SortedMap<Long, String> tail = VIRTUAL_NODE_MAP.tailMap(hash);
        if (tail.isEmpty()) {
            return VIRTUAL_NODE_MAP.firstEntry().getValue();
        }
        return tail.get(tail.firstKey());
    }

    public long hash(String key) {
        return Hashing.murmur3_128()
                .hashString(key, StandardCharsets.UTF_8)
                .asLong();
    }

    public void addShard(String shard) {
        for (int i = 0; i < VIRTUAL_NODE_SHARD_NUM; i++) {
            long hash = hash(shard + "#VN#" + i);
            VIRTUAL_NODE_MAP.put(hash, shard);
        }
    }

}

hash路由配置

模拟场景：对数据进行分库分表操作，定义了4个库和9个表，并且每个节点进行200个虚拟节点；

@Component
public class ShardingRouterConfig {

    @Bean
    public ShardingRouterComponent databaseSharding() {

        // 可以写到yml中定义
        int dbNum = 4;
        int tableNum = 9;

        // 可以写到yml中定义
        int virtualNodePerShard = 200;

        List<String> list = new ArrayList<>();
        for (int i = 0; i <= dbNum; i++) {
            list.add("db_" + i);
        }
        return new ShardingRouterComponent(list, virtualNodePerShard);
    }

    @Bean
    public ShardingRouterComponent tableSharding() {
        List<String> list = new ArrayList<>();
        for (int i = 0; i <= tableNum; i++) {
            list.add("table_" + i);
        }
        return new ShardingRouterComponent(list, virtualNodePerShard);
    }
}

测试

为了演示demo，直接在controller中进行使用，实际可以单独创建一个bean进行key路由的计算；

@RestController
@Slf4j
public class TestController {
    
    
    @Resource
    private ShardingRouterComponent databaseSharding;

    @Resource
    private ShardingRouterComponent tableSharding;
    
    @GetMapping("/test")
    public void test() throws Exception {
        // 随机一个key
        long key = System.currentTimeMillis();
        // 计算所属库
        log.info(databaseSharding.routeShard(key)); 
        // 计算所属表
        log.info(tableSharding.routeShard(key));
    }
}

数据迁移方案

一致性hash的一个优点就是：数据的扩容，影响范围最小化

比如新增了一个nodeX，并且nodeX节点的Hash值比nodeC的hash值，此时有一个数据C顺时针的第一个节点就是nodeX了，但是数据A、和数据B并不会收到影响；对于扩容后我们只需要将nodeC的数据迁移到nodeX即可，其他节点不用动

在这里插入图片描述

数据迁移方案

第一步：单独一个应用，应用会做一下操作

  • 该应用中的hash节点数是扩容后节点数据，应用通过多线程的方式对所有的表按照id升序进行查询，将查询后的数据重新计算分片键的hash值，并且将数据insert到新hash值所映射的库/表中；PS：在主体应用中 如果不做新节点的配置，是不会有数据被使用到的
  • 该应用通过Canal组件监听扩容前的所有表，如何是旧的节点表出现insert、delete、update，则需要判断分片健的hash是否匹配当前节点表，如果不匹配 就需要更新或者新增到新表中；

第二步：主体应用发布，主体应用发布后，进行以下操作

  • 主体应用成功发布后，数据的新增和修改都是在新表进行的，持续观察一段时间；

  • 独立应用再进行一个新的任务，该任务扫描旧表的所有数据，通过id进行倒叙查询

    • 如果旧数据的hash值属于新表，并且新表中不存在新表则进行新增；
    • 旧数据已经存在新表时 ，则比较旧表数据的修改时间与新表的修改时间。如果旧表数据修改时间大于新表修改时间，则更新新表数据+删除旧表数据(一个事务中)；如果旧表数据更新时间小于等于新表数据， 则直接删除旧表；

在这里插入图片描述

mysql一致性hash分表_一致性哈希算法(分库分表，负载均衡等)
weixin_36327991的博客
01-20 3386
在分布式应用中，应该来说使用到hash最多的地方就是rpc负载均衡和分库分表，通常对于正式意义上的分布式应用来说，扩容和收缩是一个半自动化的过程，在此期间，应用基本上是可用的，所以不能发生大规模动荡的意外，为了最小化潜在的影响，一致性hash算法就扮演了极为重要的角色。consistent hashing算法早在1997年就在论文1基本场景比如你有N个cache服务器(后面简称c...
MySQL-分库分表
m0_73902080的博客
08-04 2571
分库分表的中心思想是将数据分散存储，使得单一数据库/表的数据量变小来缓解单一数据库的性能问题，从而达到提升数据库性能的目的
SpringBoot_shardDB_shardTable:SpringBoot集成Sharding-JDBC实现分库分表，自定义分片算法，基于一致性hash算法，易于扩容
05-31
项目信息： 此项目是基于SpringBoot的，并在其基础上设计了 RestFul 风格的接口 。除此之外，还整合了其它的功能： 整合了swagger生成在线的接口文档，并且实现统一格式的响应及异常情况处理； 集成了 PageHelper 分页插件，支持更加友好的分页查询； 整合了 Mybatis 、Redis，以及 详细的 日志配置； 整合了 Sharding-JDBC ，实现了 分库分表，并且在分库分表中实现了自定义的分片算法; 一致性Hash算法，易于扩容； 添加了 单元测试，使用Spring提供的RestTemplate调用RestFul风格的API接口； 整合了 quartz 定时任务框架 ，并进行了封装，只需在构建完定时任务Job类后，在 application-quartz.properties 配置文件中进行简单配置即可； 实现了 reids 分布式锁 ，当项目部署集群时，
一致性哈希--分库分表
leslytt的专栏
12-19 6515
首先了解一下什么是一致性哈希，这里推荐一篇博客： http://blog.csdn.net/cywosp/article/details/23397179/分库分表是目前解决单点数据库一种比较流行的做法，也相对成熟，但都有一个共同的问题，就是随着业务的增长，之前的分库分表容量不够了，需要扩容了，这时，使用一致性哈希或者分段哈希（静态哈希+配置规则）可以尽量的减少数据的迁移。这里只谈一谈一致性哈希的
【另类见解】一致性哈希就能解决分库分表问题了？
dotNET跨平台
12-22 1749
“开局一问：分库分表行为中，一致性哈希到底用处大不大？装B脑图现在是大数据的时代，其中一个体现就是数据量非常庞大。当然大数据的概念绝非是数据量就可以定义的，我自己给大数据下的定义是：无处不...
一文搞懂分库分表算法，通俗易懂（基因法、一致性 hash、时间维度）
JmuziA的博客
04-09 2672
原因也很好理解，拿我改造过后的雪花算法来说，变量只有累加位，累加 bit 位只留 5 位，也就是最大累加 2 的 5 次方（32），累加到 4（00100）时一切正常 00100 正常参与或运算，累加到 36（100100）时，二进制有 6 位，和我们规定的 5 位超了一位，有效参与到计算的实际上是 00100，这时候变量累加位也一致了，恰好此时第 100100 的第一位 1 参与或运算对结果没影响，此时的订单号是不是就重复了！其他年的数据同理比对迁移，这个迁移好办对整个库迁移，直接改配置文件就行。
一致性hash与分库分表
江宁山人的专栏
11-01 3184
分库分表的原则： 1、当数据量较大时，需要分库分表。通常为保证某个用户的数据在同一个库同一个表中，都是按照customerId进行分库分表的。 2、有时每天产生大量数据，这些数据只是为了对账，也可以按月分库，按天分表。比如分为12个库，366张表(考虑闰年)，但数据每天用完后，可以把这些数据再迁移到历史表中，或者类似hdfs这样的表中。 3、分库分表后考虑数据库的扩容问题，同时还要保证在业务...
Mybatis Plus 数据分片-水平分库分表策略
逸轩
01-27 3314
在实际应用中，需要根据业务需求和数据量的大小，选择合适的分片键和分片规则，以达到提高数据库性能和可扩展性的目的。在使用MyBatis Plus进行数据分片时，需要谨慎处理跨库跨表的查询，注意数据迁移和扩容的问题，以确保整个数据分片系统的稳定性和可维护性。数据分片是一种处理大量数据的有效策略，但在实施过程中需要注意一些关键的事项，以确保分片系统的性能、稳定性和可维护性。分片规则的设计直接关系到数据分片的正确性，以及每个分片的数据能否被正确路由到相应的库和表中。选择合适的分片键是数据分片中至关重要的一步。
php 分库分表hash算法
10-29
分库分表是一种常见的数据库水平扩展方法，它将单一的大表分成多个小表，分散存储在不同的数据库服务器上，以提高查询效率和系统整体性能。在这个场景下，`hash算法`扮演着至关重要的角色，用于决定数据如何均匀地...
分库分表如何应用一致性hash
最新发布
02-25
### 一致性哈希算法在分库分表中的应用 #### 1. 基本原理 一致性哈希是一种用于分布式系统的负载均衡技术，能够有效地解决传统哈希方法带来的重新分配问题。当节点数量发生变化时，仅需移动少量的数据即可完成调整...
一致性哈希算法源码 Ketama一致性hash算法源码
11-28
Ketama算法是一致性hash算法的一个优秀实现。增删节点后数据命中率及均分率都很高。
关于Sharding-Sphere分库分表框架的保姆级教学！
Java技术攻略的博客
03-16 1156
的定位是一款轻量级Java框架，它会以POM依赖的形式嵌入程序，运行期间会和Java应用共享资源，这款框架的本质可以理解成是JDBC的增强版，只不过Java原生的JDBC仅支持单数据源的连接，而Java-ORM框架在执行SQL语句时，会以切面的形式拦截发往数据库的语句，接着根据配置好的数据源、分片规则和路由键，为SQL选择一个目标数据源，然后再发往对应的数据库节点处理。在整个业务系统中对性能损耗极低，但为何后面又会推出呢？因为。
一致性哈希详解
流华追梦的专栏
12-06 1890
普通的 hash 算法（hashcode % size），如果 size 发生变化，几乎所有的历史数据都需要重新hash、移动，代价非常大，常见的 Java 中的 HashMap 就是如此。那如果在 hash 表扩容或者收缩的时候 size 能够保持不变，即历史数据在 hash 表中的位置不变，这样就解决了 hash 表扩缩时的大量数据移动问题。一致性哈希可以理解为，就是 hash 函数（hashcode % size）的 size 保持不变，从而保证了hash 函数的前后一致性。
mysql 一致性hash_一致性hash算法在分表分库中的应用
weixin_29615645的博客
01-27 751
一致性hash算法结构图 分表分库结构图 可进行循环冗余存储，顺时针存储到下一个物理节点(非虚拟节点)package com.haiziwang.platform.kmcsms.route.algorithm;import java.util.Collection;import java.util.SortedMap;import java.util.TreeMap;/*** 一致性Hash算...
一致性哈希分表
qq_45749031的博客
10-17 427
表 四个表结构一样的 ceshi_a、ceshi_b、ceshi_c、ceshi_d `id` varchar(50) NOT NULL,//主键 `username` varchar(200) DEFAULT NULL,//取哈希值的字段 `hash_value` bigint(50) DEFAULT NULL,//哈希值 代码 定义 public $tableList = array();...
一致性hash分片
DBAdream的专栏
01-28 2847
一致性hash分片： 执行PartitionByMurmurHash的main方法，按上述假设会得到以下结果 index bucket ratio  0 1001836 0.1001836  1 1038892 0.1038892  2 927886 0.0927886  3 972728 0.0972728  4 1086100 0.10861  5 908616 0.090
分库分表与负载均衡的一致性hash算法
weixin_30614109的博客
08-02 172
首先了解一下什么是一致性哈希，这里推荐一篇博客： http://blog.csdn.net/cywosp/article/details/23397179/ 在分布式应用中，扩容和收缩是一个半自动化的过程，在此期间，应用基本上是可用的，所以不能发生大规模动荡的意外，为了最小化潜在的影响，这时候需要使用到一致性hash算法实现负载均衡和分库分表，hash路由算法在分布式场景下极为重要的角色...
MyCat分片规则之一致性hash分片
weixiaohuai的博客
09-11 1995
一、简介 实现方式：一致性hash分片，利用一个分片节点对应一个或者多个虚拟hash桶的思想，，尽可能减少分片扩展时的数据迁移。 优点：有效解决了分布式数据库的扩容问题。 缺点：在横向扩展的时候，需要迁移部分数据；由于虚拟桶倍数与分片节点数都必须是正整数，而且要服从"虚拟桶倍数×分片节点数=设计极限"，因此在横向扩容的过程中，增加分片节点并不是一台一台地加上去的，而是以一种因式分解的方...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一恍过去

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值