一致性hash算法

普通hash算法

以客户端连接服务器为例，假设有3台tomcat，编号为tomcat0、tomcat1、tomcat2，N个客户端连接，此时要使用hash算法路由客户端连接的服务器。

路由计算

假设每个客户端都有唯一的id，例如客户端id分别为5、6、7、8，一共4个客户端，计算路由如下：
客户端id=5，计算路由：5%3=2，连接服务器为tomcat2
客户端id=6，计算路由：6%3=0，连接服务器为tomcat0
客户端id=7，计算路由：7%3=1，连接服务器为tomcat1
客户端id=8，计算路由：8%3=2，连接服务器为tomcat2

服务器下线

假如服务器tomcat2下线，那么会重新计算路由：
客户端id=5，计算路由：5%2=1，连接服务器为tomcat1
客户端id=6，计算路由：6%2=0，连接服务器为tomcat0
客户端id=7，计算路由：7%2=1，连接服务器为tomcat1
客户端id=8，计算路由：8%2=0，连接服务器为tomcat0

问题

服务器上线和下线，都会改变hash算法取模参数，进而导致客户端连接重新路由到其他服务器，影响较大。

一致性hash算法

一致性hash算法是将0~2^31-1这样一个范围的值，形成hash环，每个值都相当于一个地址，客户端连接时，计算客户端的hash值，然后按顺时针方向归属服务器，如下图，假如客户端hash值在节点1和节点2之间，客户端会路由到节点2。

服务器下线

服务器下线时，假如节点2下线，原来连接节点2的客户端会重新连接到节点3，其他节点不受影响。

数据倾斜问题

假如一共两台服务器，两台服务器计算出来的hash值，差值太小，可能有很多客户端连接在节点1上，一小部分连接在节点2上，那么会出现数据倾斜，如下图，只看左侧圈住的地方。

一致性hash+虚拟节点

为了解决数据倾斜，可以给每个节点多次计算hash值，每个hash值，称为虚拟节点，多个虚拟节点对应一个真实节点，虚拟节点会均匀分布。如下图右侧圈住的地方。

假如有tomcat0，tomcat1，针对tomcat0进行3次hash计算得到1，2，3，3个hash值，这3个hash值落到hash环上，每个点称为tomcat0的虚拟节点；tomcat1同上计算虚拟节点。这样可以保证多个虚拟节点的位置尽量均匀分布，解决数据倾斜的问题。

算法

普通hash算法

public class GeneralHash {
    public static void main(String[] args) {
        // 定义客户端IP
        String[] clients = new String[]{"10.78.12.3","113.25.63.1","126.12.3.8"};
        // 定义服务器数量
        int serverCount = 5;// (编号对应0，1，2)
        // hash(ip)%node_counts=index
        //根据index锁定应该路由到的tomcat服务器
        for(String client: clients) {
            int hash = Math.abs(client.hashCode());
            int index = hash%serverCount;
            System.out.println("客户端：" + client + " 被路由到服务器编号为：" + index);
        }
    }
}

一致性hash算法

import java.util.SortedMap;
import java.util.TreeMap;

public class ConsistentHashNoVirtual {

    public static void main(String[] args) {
        //step1 初始化：把服务器节点IP的哈希值对应到哈希环上
        // 定义服务器ip
        String[] tomcatServers = new String[]{"123.111.0.0","123.101.3.1","111.20.35.2","123.98.26.3"};

        SortedMap<Integer,String> hashServerMap = new TreeMap<>();

        for(String tomcatServer: tomcatServers) {
            // 求出每一个ip的hash值，对应到hash环上，存储hash值与ip的对应关系
            int serverHash = Math.abs(tomcatServer.hashCode());
            // 存储hash值与ip的对应关系
            hashServerMap.put(serverHash,tomcatServer);

        }

        //step2 针对客户端IP求出hash值
        // 定义客户端IP
        String[] clients = new String[]{"10.78.12.3","113.25.63.1","126.12.3.8"};
        for(String client : clients) {
            int clientHash = Math.abs(client.hashCode());
            //step3 针对客户端,找到能够处理当前客户端请求的服务器（哈希环上顺时针最近）
            // 根据客户端ip的哈希值去找出哪一个服务器节点能够处理（）
            SortedMap<Integer, String> integerStringSortedMap = hashServerMap.tailMap(clientHash);
            if(integerStringSortedMap.isEmpty()) {
                // 取哈希环上的顺时针第一台服务器
                Integer firstKey = hashServerMap.firstKey();
                System.out.println("==========>>>>客户端：" + client + " 被路由到服务器：" + hashServerMap.get(firstKey));
            }else{
                Integer firstKey = integerStringSortedMap.firstKey();
                System.out.println("==========>>>>客户端：" + client + " 被路由到服务器：" + hashServerMap.get(firstKey));
            }
        }
    }
}

一致性hash算法（虚拟节点）

import java.util.SortedMap;
import java.util.TreeMap;
import java.util.UUID;

public class ConsistentHashWithVirtual {

    public static void main(String[] args) {
        //step1 初始化：把服务器节点IP的哈希值对应到哈希环上
        // 定义服务器ip
        String[] tomcatServers = new String[]{"123.111.0.0","123.101.3.1","111.20.35.2","123.98.26.3"};
        SortedMap<Integer,String> hashServerMap = new TreeMap<>();

        // 定义针对每个真实服务器虚拟出来几个节点
        int virtaulCount = 3;

        for(String tomcatServer: tomcatServers) {
            // 求出每一个ip的hash值，对应到hash环上，存储hash值与ip的对应关系
            int serverHash = Math.abs(tomcatServer.hashCode());
            // 存储hash值与ip的对应关系
            hashServerMap.put(serverHash,tomcatServer);

            // 处理虚拟节点
            for(int i = 0; i < virtaulCount; i++) {
                int virtualHash = Math.abs((tomcatServer + "#" + i).hashCode());
                hashServerMap.put(virtualHash,"----由虚拟节点"+ i  + "映射过来的请求："+ tomcatServer);
            }

        }
        
        //step2 针对客户端IP求出hash值
        // 定义客户端IP
        String[] clients = new String[]{"10.78.12.3","113.25.63.1","126.12.3.8"};
        for(String client : clients) {
            int clientHash = Math.abs(client.hashCode());
            //step3 针对客户端,找到能够处理当前客户端请求的服务器（哈希环上顺时针最近）
            // 根据客户端ip的哈希值去找出哪一个服务器节点能够处理（）
            SortedMap<Integer, String> integerStringSortedMap = hashServerMap.tailMap(clientHash);
            if(integerStringSortedMap.isEmpty()) {
                // 取哈希环上的顺时针第一台服务器
                Integer firstKey = hashServerMap.firstKey();
                System.out.println("==========>>>>客户端：" + client + " 被路由到服务器：" + hashServerMap.get(firstKey));
            }else{
                Integer firstKey = integerStringSortedMap.firstKey();
                System.out.println("==========>>>>客户端：" + client + " 被路由到服务器：" + hashServerMap.get(firstKey));
            }
        }
    }
}