コンシステント ハッシュの秘密

序文

---

数日前、私は Ant Financial ソファ ブログに注意を払い、slotTable とコンシステント ハッシュ アルゴリズムに言及したソファレジストリを説明する記事に出くわしました。実はバグウェンは前回のインタビューにもよく登場していたのですが、今日はその模様をじっくりと見ていきましょう。

• SOFARegistryソースコード｜データ断片化の核心～ルーティングテーブルSlotTable解析

バックグラウンド

---

この設計は、データを分割して異なるスロットに分散する redis スロットなど、多くのオープン ソース ミドルウェアで使用され、データの水平方向のスケーラビリティを向上させます。SofaRegistry もデータを格納する際にこの設計を採用しているため、ミドルウェアをクラスターにデプロイでき、データは特定のルールに従って各ノードに分散され、全体的なスケーラビリティが向上します。

データのスケーラビリティ

---

一般に、水平展開、垂直展開、垂直展開は、車の購入、サンルーフのオープン、ハイエンドオーディオの構成など、構成を追加することであり、構成は完全であり、同じサーバーとデータベースも構成でいっぱいになる可能性があります。横展開＋1両では足りず、需要が収まるまで2両追加

横展開、すべてのデータを1つのテーブルに入れると、その横展開は絶対にできません.このとき、サブデータベースとサブテーブルを考えます.sharedjdbc実際には、特定のフィールドが特定のアルゴリズムでは、ヒットするテーブルとライブラリを決定するので、データ分割により、テーブルとデータベースの数を増やすことで、データ ストレージの量を増やすことができます。

特定のキーと特定のアルゴリズム計算により、ノードの数を分割し、データがこれらのノードに割り当てられるようにします

分割アルゴリズムの欠陥

---

可分アルゴリズムはデータ分割の効果を達成できますが、ノードの増減のためにすべてのデータを再分配する必要があり、間違いなくコストが増加します。この状況に対応して、コンシステント ハッシュ アルゴリズムが登場します。

コンシステント ハッシュ アルゴリズム

---

まず、このアルゴリズムはすべての値をリングに格納します。たとえば、data1 の位置は、上の領域にある限り Node1 に属し、下の領域は Node2 に属するため、data2 は該当しません。ノード 2 でストレージ用に。

新しいノードの状況

比如说现在增加节点Node3，data1数据不会变，只是data2的数据从原本Node2迁移到Node3去。这样只会影响一部分数据。

减少节点情况

这时如果把Node2干掉，那么我们只需要将data2迁移到Node1，不会影响之前Node1的数据。

总结

从上面情况来看，一致性hash算法对于新增、删除节点，只是会影响部分数据。

数据倾斜问题

---

当我们节点分配不好的时候，就会出现某个节点数据贼多，这样会导致大部分请求都跑去某个节点，该节点压力会很多，其他节点又没有流量。那这个时候解决方案就是增加虚拟节点。

新增了Node1-1、Node2-1虚拟节点，这样数据就不会因为划分不均匀导致数据倾斜。

实践

---

我尝试的是带有虚拟节点的方案

//总节点数据，包括实际上节点，还有虚拟节点
static NavigableMap<Integer, List<String>> map = new TreeMap<>();

//收集实际上节点对应哪些虚拟节点
static Map<String, List<Integer>> map1 = new HashMap<>();

public static void main(String[] args) {
    int a = 0;

    while (a < 4) {
        String ip = "172.29.3." + a;

        map.put(hashcode(ip), new ArrayList<>());
        map1.put(ip, new ArrayList<>(List.of(hashcode(ip))));

        for (int b = 0; b < 150; b++) {
            int number = hashcode(ip + "#" + RandomUtil.randomInt(5));

            map.put(number, new ArrayList<>());

            List<Integer> list = map1.get(ip);

            if (CollectionUtil.isEmpty(list)) {
                map1.put(ip, new ArrayList<>(List.of(number)));
            } else {
                map1.get(ip).add(number);
            }
        }
        a++;
    }

    int i = 0;

    while (i < 8000000) {
        String msg = RandomUtil.randomString(20);
        get(map, msg, map1).add(msg);
        i++;
    }

    map1.forEach((k, v) -> {
        System.out.println(k + " " + map.get(hashcode(k)).size());
    });
}

private static void remove(String ip) {
    List<Integer> idList = map1.get(ip);

    map1.remove(ip);

    idList.forEach(id->map.remove(id));
}

//使用FNV1_32_HASH算法计算服务器的Hash值,这里不使用重写hashCode的方法，最终效果没区别
private static int hashcode(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 List<String> get(NavigableMap<Integer, List<String>> map, String msg, Map<String, List<Integer>> map1) {
    Map.Entry<Integer, List<String>> entry = map.ceilingEntry(hashcode(msg));

    AtomicReference<List<String>> list = new AtomicReference<>();

    if (entry == null) {
        map1.forEach((k, v) -> {
            if (v.contains(map.firstEntry().getKey())) {
                list.set(map.get(hashcode(k)));
            }
        });
    } else {
        map1.forEach((k, v) -> {
            if (v.contains(entry.getKey())) {
                list.set(map.get(hashcode(k)));
            }
        });
    }

    return list.get();
}
复制代码

1. 有两个map，一个储存实际节点+虚拟节点数据的map，另一个是收集实际节点对应哪些虚拟节点

//总节点数据，包括实际上节点，还有虚拟节点
static NavigableMap<Integer, List<String>> map = new TreeMap<>();

//收集实际上节点对应哪些虚拟节点
static Map<String, List<Integer>> map1 = new HashMap<>();
复制代码

2. 造了4个节点，我是以ip+"#"+随机数5位来作为值，但是ip呢经过实验，如果不是临近的话，数据分配还是不理想，我们可以这样做实际ip映射为172.29.3.xx，172.29.3.xx作为一个key去储存。

这里是往刚刚两个map储存数据

int a = 0;

while (a < 4) {
    String ip = "172.29.3." + a;

    map.put(hashcode(ip), new ArrayList<>());
    map1.put(ip, new ArrayList<>(List.of(hashcode(ip))));

    for (int b = 0; b < 150; b++) {
        int number = hashcode(ip + "#" + RandomUtil.randomInt(5));

        map.put(number, new ArrayList<>());

        List<Integer> list = map1.get(ip);

        if (CollectionUtil.isEmpty(list)) {
            map1.put(ip, new ArrayList<>(List.of(number)));
        } else {
            map1.get(ip).add(number);
        }
    }
    a++;
}
复制代码

3. 这个是一致性hash算法的一部分了，ceilingEntry找到当前key比它大的节点，如果不存在则拿第一个节点。

private static List<String> get(NavigableMap<Integer, List<String>> map, String msg, Map<String, List<Integer>> map1) {
    Map.Entry<Integer, List<String>> entry = map.ceilingEntry(hashcode(msg));

    AtomicReference<List<String>> list = new AtomicReference<>();

    if (entry == null) {
        map1.forEach((k, v) -> {
            if (v.contains(map.firstEntry().getKey())) {
                list.set(map.get(hashcode(k)));
            }
        });
    } else {
        map1.forEach((k, v) -> {
            if (v.contains(entry.getKey())) {
                list.set(map.get(hashcode(k)));
            }
        });
    }

    return list.get();
}
复制代码

4. hash算法

//使用FNV1_32_HASH算法计算服务器的Hash值,这里不使用重写hashCode的方法，最终效果没区别
private static int hashcode(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;
}
复制代码

5. 跑下程序

172.29.3.3 1834587
172.29.3.2 1805299
172.29.3.1 1892821
172.29.3.0 2467293
复制代码

我们可以看到数据蛮均匀的分配的。

实战

---

上面的例子，比如说删除节点，里面数据没有做迁移的，这个纠结需不需要迁移呢？

需要迁移的，大家可以自行了解下redis slots槽的设计，如果集群里面新增节点，需要人工去手动将slot移动到新的节点，减少也是一样的操作。

• Redis集群(中) —— 集群伸缩