一致性Hash问题和解决方案

一.一致性Hash算法

Hash算法，⽐如说在安全加密领域MD5、SHA等加密算法，在数据存储和查找⽅⾯有Hash表等, 以上
都应⽤到了Hash算法

1.为什么需要使⽤Hash?

 较多运用在存储和查找领域，最经典的就是Hash表，查询效率⾮常之⾼，哈希算法如果设计的⽐较ok的话，那么Hash表的数据查询时间复杂度可以接近于O(1)。
 
**Hash表的查询效率⾼不⾼取决于Hash算**

2.Hash算法应⽤场景

Hash算法在分布式集群架构中的应用场景。分布式集群架构Redis、Hadoop、ElasticSearch，
Mysql分库分表，Nginx负载均衡等

主要作用的应用场景归纳为两个：
1.请求的负载均衡（比如Nginx的ip_hash策略）

 - Nginx的IP_hash策略可以在客户端ip不变的情况下，将其发出的请求始终路由到同⼀个⽬标服务
   器上，实现会话粘滞，避免处理session共享问题
   
 - 如果没有IP_hash策略，那么如何实现会话粘滞？
 	可以维护⼀张映射表，存储客户端IP或者sessionid与具体⽬标服务器的映射关系.<ip,tomcat>
 	缺点：
 		1.在客户端很多的情况下，映射表非常大，浪费内存空间
 		2.客户端上下线和目标服务器上下线，都会导致重新维护映射表，映射表维护成本很大
 		
如果使⽤哈希算法，我们可以对ip地址或者sessionid进⾏计算哈希值，哈希值与服务器数量进⾏取模运算，得到的值就是当前请求应该被路由到的服务器编号，如此，同⼀个客户端ip发送过来的请求就可以路由到同⼀个⽬标服务器，实现会话粘滞。 	

2.分布式存储

 - 以分布式内存数据库Redis为例,集群中有redis1，redis2，redis3 三台Redis服务器
   那么,在进⾏数据存储时,<key1,value1>数据存储到哪个服务器当中呢？针对key进⾏hash处理
   hash(key1)%3=index, 使⽤余数index锁定存储的具体服务器节点

3.普通Hash算法存在的问题

普通Hash算法存在⼀个问题，以ip_hash为例，假定下载⽤户ip固定没有发⽣改变，现在tomcat3出现
了问题，down机了，服务器数量由3个变为了2个，之前所有的求模都需要重新计算

3.⼀致性Hash算法

⼀致性哈希算法思路如下：

⾸先有⼀条直线，直线开头和结尾分别定为为1和2的32次⽅减1，这相当于⼀个地址。

对于这样⼀条线，弯过来构成⼀个圆环形成闭环，这样的⼀个圆环称为hash环。

我们把服务器的ip或者主机名求hash值然后对应到hash环上。

那么针对客户端⽤户，也根据它的ip进⾏hash求值，对应到环上某个位置，然后客户端路按照顺时针⽅向找最近的服务器节点

假如将服务器3下线，服务器3下线后，原来路由到3的客户端重新路由到服务器4。
对于其他客户端没有影响只是这⼀⼩部分受影响（请求的迁移达到了最⼩，这样的算法对分布式集群来说⾮常合适的，避免了⼤量请求迁移 ）

增加服务器5之后，原来路由到3的部分客户端路由到新增服务器5上，对于其他客户端没有影响只是这⼀⼩部分受影响（请求的迁移达到了最⼩，这样的算法对分布式集群来说⾮常合适的，避免了⼤量请求迁移 ）

1）如前所述，每⼀台服务器负责⼀段，⼀致性哈希算法对于节点的增减都只需重定位环空间中的⼀⼩
部分数据，具有较好的容错性和可扩展性。

但是，⼀致性哈希算法在服务节点太少时，容易因为节点分部不均匀⽽造成数据倾斜问题。例如系统中
只有两台服务器，其环分布如下，节点2只能负责⾮常⼩的⼀段，⼤量的客户端
请求落在了节点1上，这就是数据（请求）倾斜问题

2）为了解决这种数据倾斜问题，⼀致性哈希算法引⼊了虚拟节点机制，即对每⼀个服务节点计算多个
哈希，每个计算结果位置都放置⼀个此服务节点，称为虚拟节点。

具体做法可以在服务器ip或主机名的后⾯增加编号来实现。⽐如，可以为每台服务器计算三个虚拟节
点，于是可以分别计算 “节点1的ip#1”、“节点1的ip#2”、“节点1的ip#3”、“节点2的ip#1”、“节点2的
ip#2”、“节点2的ip#3”的哈希值，于是形成六个虚拟节点，当客户端被路由到虚拟节点的时候其实是被
路由到该虚拟节点所对应的真实节点

4.⼿写实现⼀致性Hash算法

1.普通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);
		}
	}
}

2.⼀致性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));
			}
		}
	}
}

3.⼀致性Hash算法实现（含虚拟节点）
import java.util.SortedMap;
import java.util.TreeMap;
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));
			}
		}
	}
}

5.Nginx 配置⼀致性Hash负载均衡策略

ngx_http_upstream_consistent_hash 模块是⼀个负载均衡器，使⽤⼀个内部⼀致性hash算法来选择
合适的后端节点。
该模块可以根据配置参数采取不同的⽅式将请求均匀映射到后端机器，
consistent_hash $remote_addr：可以根据客户端ip映射
consistent_hash $request_uri：根据客户端请求的uri映射
consistent_hash $args：根据客户端携带的参数进⾏映
ngx_http_upstream_consistent_hash 模块是⼀个第三⽅模块，需要我们下载安装后使⽤
1）github下载nginx⼀致性hash负载均衡模块 https://github.com/replay/ngx_http_consistent_hash

2）将下载的压缩包上传到nginx服务器，并解压
3）我们已经编译安装过nginx，此时进⼊当时nginx的源码⽬录，执⾏如下命令
./configure —add-module=/root/ngx_http_consistent_hash-master
make
make install
4）Nginx就可以使⽤啦，在nginx.conf⽂件中配置