数据库分库分表策略

m0_57801749

已于 2024-05-21 20:19:40 修改

阅读量1k

点赞数 31

分类专栏：算法文章标签：哈希算法算法

于 2024-05-21 18:50:36 首次发布

本文链接：https://blog.csdn.net/m0_57801749/article/details/139099806

版权

算法专栏收录该内容

1 篇文章 0 订阅

订阅专栏

常用策略：

（1）数据范围分库分表：比如将ID1～1000W的数据存放在第一个表或库中，ID 1000W-2000W数据存放在第二个表或库中，以此类推

（2）时间范围分库分表：比如将第一季度的数据存放在第一个表或库中，第二个季度数据存放在第二个表或库中，以此类推

缺点：

数据倾斜：因为某些时间段的数据的多少是不确定的，可能会出现数据量超过预期而造成的查询性能下降，或者是数据量远远小于预期造成的空间浪费。
未分担压力：分库分表的一个主要目的是避免单节点的数据量过大造成性能下降。另一个目的是可以在高并发的场景下分担压力，一般最近最新的数据较频繁访问，而老的数据访问量较小或基本不会访问，因此会造成数据库压力分担不均匀。

（3）取模哈希分库分表：将某个数据进行哈希后进行取模，然后映射到对应的库或表中，这个模一般就是库的个数或者表的个数，所以取模哈希分库分表，库个数一般是固定的

存在问题：

当现有的表和库容量不足，也就是需要扩容的时候涉及到数据迁移的问题，因为模数变了，之前的数据全部都需要重新取模重新分配到新的库和表中，不然就会出现“查无此人”的错误了。

📢：（4）一致性哈希

只要是使用哈希这种方式，在改变模个数后一定是要迁移数据的，一致性哈希可以降低迁移量以及带来的风险。

作用场景：

一致性哈希算法是一种特殊的哈希算法，通常用于分布式系统中，比如分布式缓存、分布式数据库等解决数据的分配和负载均衡的场景。

概念：

一致性hash：对节点和数据，都做一次hash运算，然后比较节点和数据的hash值，数据值和节点最相近的节点作为处理节点。为了分布得更均匀，通过使用虚拟节点的方式，每个节点计算出n个hash值，均匀地放在hash环上，这样数据就能比较均匀地分布到每个节点。

一致性hash解决几个问题：

数据库分库分表，遇到存储瓶颈需要增加分库分表，如果分片规则是取模的方式，那么就需要所有的数据重新计算取模，然后扩容后全量做数据迁移。如果是一致性hash的方式，只需要增加扩容部分机器，然后基于扩容后的一致性hash结果迁移部分数据即可。
负载均衡，如果遇到服务集群中某一台机器故障，一致性hash会将原本应该打到这台机器的请求做一致性hash后按虚拟节点分发给其他正常服务，这样是服务压力会更均衡。包括扩容时一样，不需要去调整负载均衡的分片规则，增加了服务后环形hash上自然会增加相应的虚拟节点，服务也会更均衡地落到每一台机器上。

原理

1、环形Hash空间

按照常用的hash算法来将对应的key哈希到一个具有2的32次方个桶的空间中，即0~(232)-1的数字空间中。现在我们可以将这些数字头尾相连，想象成一个闭合的环形。如下图

(2)把数据通过一定的hash算法处理后映射到环上

现在我们将object1、object2、object3、object4四个对象通过特定的Hash函数计算出对应的key值，然后散列到Hash环上。

如下图：

Hash(object1) = key1；

Hash(object2) = key2；

Hash(object3) = key3；

Hash(object4) = key4；

(3)将机器通过hash算法映射到环上在采用一致性哈希算法的分布式集群中将新的机器加入，其原理是通过使用与对象存储一样的Hash算法将机器也映射到环中（一般情况下对机器的hash计算是采用机器的IP或者机器唯一的别名作为输入值），然后以顺时针的方向计算，将所有对象存储到离自己最近的机器中。假设现在有NODE1，NODE2，NODE3三台机器，通过Hash算法得到对应的KEY值，映射到环中，其示意图如下：

Hash(NODE1) = KEY1;

Hash(NODE2) = KEY2;

Hash(NODE3) = KEY3;

通过上图可以看出对象与机器处于同一哈希空间中，这样按顺时针转动object1存储到了NODE1中，object3存储到了NODE2中，object2、object4存储到了NODE3中。在这样的部署环境中，hash环是不会变更的，因此，通过算出对象的hash值就能快速的定位到对应的机器中，这样就能找到对象真正的存储位置了。

2、机器的删除与添加

普通hash求余算法最为不妥的地方就是在有机器的添加或者删除之后会造成大量的对象存储位置失效。下面来分析一下一致性哈希算法是如何处理的。 (1)节点（机器）的删除 以上面的分布为例，如果NODE2出现故障被删除了，那么按照顺时针迁移的方法，object3将会被迁移到NODE3中，这样仅仅是object3的映射位置发生了变化，其它的对象没有任何的改动。如下图：

(2)节点（机器）的添加如果往集群中添加一个新的节点NODE4，通过对应的哈希算法得到KEY4，并映射到环中，如下图：

通过按顺时针迁移的规则，那么object2被迁移到了NODE4中，其它对象还保持着原有的存储位置。通过对节点的添加和删除的分析，一致性哈希算法在保持了单调性的同时，还是数据的迁移达到了最小，这样的算法对分布式集群来说是非常合适的，避免了大量数据迁移，减小了服务器的的压力。

3、平衡性–虚拟节点

根据上面的图解分析，一致性哈希算法满足了单调性和负载均衡的特性以及一般hash算法的分散性，但这还并不能当做其被广泛应用的原由，因为还缺少了平衡性。下面将分析一致性哈希算法是如何满足平衡性的。 hash算法是不保证平衡的，如上面只部署了NODE1和NODE3的情况（NODE2被删除的图），object1存储到了NODE1中，而object2、object3、object4都存储到了NODE3中，这样就造成了非常不平衡的状态。在一致性哈希算法中，为了尽可能的满足平衡性，其引入了虚拟节点。 ——“虚拟节点”（ virtual node ）是实际节点（机器）在 hash 空间的复制品（ replica ），一个实际节点（机器）对应了若干个“虚拟节点”，这个对应个数也成为“复制个数”，“虚拟节点”在 hash 空间中以hash值排列。以上面只部署了NODE1和NODE3的情况（NODE2被删除的图）为例，之前的对象在机器上的分布很不均衡，现在我们以2个副本（复制个数）为例，这样整个hash环中就存在了4个虚拟节点，最后对象映射的关系图如下：

根据上图可知对象的映射关系：

object1->NODE1-1，

object2->NODE1-2，

object3->NODE3-2，

object4->NODE3-1。

通过虚拟节点的引入，对象的分布就比较均衡了。那么在实际操作中，正真的对象查询是如何工作的呢？对象从hash到虚拟节点到实际节点的转换如下图

“虚拟节点”的hash计算可以采用对应节点的IP地址加数字后缀的方式。

例如假设NODE1的IP地址为192.168.1.100。引入“虚拟节点”前，计算 cache A 的 hash 值： Hash(“192.168.1.100”);

引入“虚拟节点”后，计算“虚拟节”点NODE1-1和NODE1-2的hash值： Hash(“192.168.1.100#1”); // NODE1-1

Hash(“192.168.1.100#2”); // NODE1-2

当某个节点被删除时：将该节点中的数据全部取出，按照剩余节点的hash位置，将删除节点中的数据重新hash到其他节点。

当增加某个节点时：将该节点前的到下一个节点之间的数据取出，重新hash

不带虚拟节点的

package hash;  
  
import java.util.SortedMap;  
import java.util.TreeMap;  
  
/** 
 * 不带虚拟节点的一致性Hash算法 
 * 重点：1.如何造一个hash环，2.如何在哈希环上映射服务器节点，3.如何找到对应的节点
 */  
public class ConsistentHashingWithoutVirtualNode {  
  
    //待添加入Hash环的服务器列表  
    private static String[] servers = { "192.168.0.0:111", "192.168.0.1:111",  
            "192.168.0.2:111", "192.168.0.3:111", "192.168.0.4:111" };  
  
    //key表示服务器的hash值，value表示服务器  
    private static SortedMap<Integer, String> sortedMap = new TreeMap<Integer, String>();  
  
    //程序初始化，将所有的服务器放入sortedMap中  
    static {  
        for (int i=0; i<servers.length; i++) {  
            int hash = getHash(servers[i]);  
            System.out.println("[" + servers[i] + "]加入集合中, 其Hash值为" + hash);  
            sortedMap.put(hash, servers[i]);  
        }  
        System.out.println();  
    }  
  
    //得到应当路由到的结点  
    private static String getServer(String key) {  
        //得到该key的hash值  
        int hash = getHash(key);  
        //得到大于该Hash值的所有Map  
        SortedMap<Integer, String> subMap = sortedMap.tailMap(hash);  
        if(subMap.isEmpty()){  
            //如果没有比该key的hash值大的，则从第一个node开始  
            Integer i = sortedMap.firstKey();  
            //返回对应的服务器  
            return sortedMap.get(i);  
        }else{  
            //第一个Key就是顺时针过去离node最近的那个结点  
            Integer i = subMap.firstKey();  
            //返回对应的服务器  
            return subMap.get(i);  
        }  
    }  
      
    //使用FNV1_32_HASH算法计算服务器的Hash值,这里不使用重写hashCode的方法，最终效果没区别  
    private static int getHash(String str) {  
        final int p = 16777619;  
        int hash = (int) 2166136261L;  
        for (int i = 0; i < str.length(); i++)  
            hash = (hash ^ str.charAt(i)) * p;  
        hash += hash << 13;  
        hash ^= hash >> 7;  
        hash += hash << 3;  
        hash ^= hash >> 17;  
        hash += hash << 5;  
  
        // 如果算出来的值为负数则取其绝对值  
        if (hash < 0)  
            hash = Math.abs(hash);  
        return hash;  
        }  
  
    public static void main(String[] args) {  
        String[] keys = {"太阳", "月亮", "星星"};  
        for(int i=0; i<keys.length; i++)  
            System.out.println("[" + keys[i] + "]的hash值为" + getHash(keys[i])  
                    + ", 被路由到结点[" + getServer(keys[i]) + "]");  
    }  
}

带虚拟节点的

  /** 
  * 带虚拟节点的一致性Hash算法 
  */  
 public class ConsistentHashingWithoutVirtualNode {  
  
     //待添加入Hash环的服务器列表  
     private static String[] servers = {"192.168.0.0:111", "192.168.0.1:111", "192.168.0.2:111",  "192.168.0.3:111", "192.168.0.4:111"};  
       
     //真实结点列表,考虑到服务器上线、下线的场景，即添加、删除的场景会比较频繁，这里使用LinkedList会更好  
     private static List<String> realNodes = new LinkedList<String>();  
       
     //虚拟节点，key表示虚拟节点的hash值，value表示虚拟节点的名称  
     private static SortedMap<Integer, String> virtualNodes = new TreeMap<Integer, String>();  
               
     //虚拟节点的数目，这里写死，为了演示需要，一个真实结点对应5个虚拟节点  
     private static final int VIRTUAL_NODES = 5;  
       
     static{  
         //先把原始的服务器添加到真实结点列表中  
         for(int i=0; i<servers.length; i++)  
             realNodes.add(servers[i]);  
           
         //再添加虚拟节点，遍历LinkedList使用foreach循环效率会比较高  
         for (String str : realNodes){  
             for(int i=0; i<VIRTUAL_NODES; i++){  
                 String virtualNodeName = str + "&&VN" + String.valueOf(i);  
                 int hash = getHash(virtualNodeName);  
                 System.out.println("虚拟节点[" + virtualNodeName + "]被添加, hash值为" + hash);  
                 virtualNodes.put(hash, virtualNodeName);  
             }  
         }  
         System.out.println();  
     }  
       
     //使用FNV1_32_HASH算法计算服务器的Hash值,这里不使用重写hashCode的方法，最终效果没区别  
     private static int getHash(String str){  
         final int p = 16777619;  
         int hash = (int)2166136261L;  
         for (int i = 0; i < str.length(); i++)  
             hash = (hash ^ str.charAt(i)) * p;  
         hash += hash << 13;  
         hash ^= hash >> 7;  
         hash += hash << 3;  
         hash ^= hash >> 17;  
         hash += hash << 5;  
           
         // 如果算出来的值为负数则取其绝对值  
         if (hash < 0)  
             hash = Math.abs(hash);  
         return hash;  
     }  
       
     //得到应当路由到的结点  
     private static String getServer(String key){  
        //得到该key的hash值  
         int hash = getHash(key);  
         // 得到大于该Hash值的所有Map  
         SortedMap<Integer, String> subMap = virtualNodes.tailMap(hash);  
         String virtualNode;  
         if(subMap.isEmpty()){  
            //如果没有比该key的hash值大的，则从第一个node开始  
            Integer i = virtualNodes.firstKey();  
            //返回对应的服务器  
            virtualNode = virtualNodes.get(i);  
         }else{  
            //第一个Key就是顺时针过去离node最近的那个结点  
            Integer i = subMap.firstKey();  
            //返回对应的服务器  
            virtualNode = subMap.get(i);  
         }  
         //virtualNode虚拟节点名称要截取一下  
         if(StringUtils.isNotBlank(virtualNode)){  
             return virtualNode.substring(0, virtualNode.indexOf("&&"));  
         }  
         return null;  
     }  
       
     public static void main(String[] args){  
         String[] keys = {"太阳", "月亮", "星星"};  
         for(int i=0; i<keys.length; i++)  
             System.out.println("[" + keys[i] + "]的hash值为" +  
                     getHash(keys[i]) + ", 被路由到结点[" + getServer(keys[i]) + "]");  
     }  
 }

m0_57801749

关注

31
点赞
踩
23

收藏

觉得还不错? 一键收藏
1
评论
数据库分库分表策略

(3)将机器通过hash算法映射到环上在采用一致性哈希算法的分布式集群中将新的机器加入，其原理是通过使用与对象存储一样的Hash算法将机器也映射到环中（一般情况下对机器的hash计算是采用机器的IP或者机器唯一的别名作为输入值），然后以顺时针的方向计算，将所有对象存储到离自己最近的机器中。通过对节点的添加和删除的分析，一致性哈希算法在保持了单调性的同时，还是数据的迁移达到了最小，这样的算法对分布式集群来说是非常合适的，避免了大量数据迁移，减小了服务器的的压力。，不然就会出现“查无此人”的错误了。
复制链接

扫一扫