分布式场景

一致性Hash算法

Hash算法在很多分布式集群产品中都有应⽤，⽐如分布式集群架构Redis、Hadoop、ElasticSearch，

Mysql分库分表，Nginx负载均衡等

主要的应⽤场景归纳起来两个

• 请求的负载均衡（⽐如nginx的ip_hash策略）

Nginx的IP_hash策略可以在客户端ip不变的情况下，将其发出的请求始终路由到同⼀个⽬标服务
器上，实现会话粘滞，避免处理session共享问题
如果没有IP_hash策略，那么如何实现会话粘滞？
可以维护⼀张映射表，存储客户端IP或者sessionid与具体⽬标服务器的映射关系
<ip,tomcat1>
缺点
1）那么，在客户端很多的情况下，映射表⾮常⼤，浪费内存空间
2）客户端上下线，⽬标服务器上下线，都会导致重新维护映射表，映射表维护成本很⼤

• 分布式存储

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

Hash算法实现

• 普通Hash算法实现

/**
* 普通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;
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的哈希值去找出哪⼀个服务器节点能够处理（）
第 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
 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));
 }
 }
 }
}

分布式ID

• UUID(可以⽤)

UUID 是指Universally Unique Identifier，翻译为中⽂是通⽤唯⼀识别码
产⽣重复 UUID 并造成错误的情况⾮常低，是故⼤可不必考虑此问题。
Java中得到⼀个UUID，可以使⽤java.util包提供的⽅法

• SnowFlake 雪花算法（可以⽤，推荐）

雪花算法是Twitter推出的⼀个⽤于⽣成分布式ID的策略。
雪花算法是⼀个算法，基于这个算法可以⽣成ID，⽣成的ID是⼀个long型，那么在Java中⼀个long
型是8个字节，算下来是64bit，如下是使⽤雪花算法⽣成的⼀个ID的⼆进制形式示意：

• 借助Redis的Incr命令获取全局唯⼀ID（推荐）

Redis Incr 命令将 key 中储存的数字值增⼀。如果 key 不存在，那么 key 的值会先被初始化为 0
，然后再执⾏ INCR 操作

Jedis jedis = new Jedis("127.0.0.1",6379);
try {
 long id = jedis.incr("id");
 System.out.println("从redis中获取的分布式id为：" + id);
} finally {
 if (null != jedis) {
 jedis.close();
 } }

Session共享问题

解决Session⼀致性的⽅案

• Nginx的 IP_Hash 策略（可以使⽤）

  同⼀个客户端IP的请求都会被路由到同⼀个⽬标服务器，也叫做会话粘滞

​ 优点：

​ 配置简单，不⼊侵应⽤，不需要额外修改代码

​ 缺点：

​ 服务器重启Session丢失

​ 存在单点负载⾼的⻛险

​ 单点故障问题

• Session共享，Session集中存储**（推荐）**

  Session的本质就是缓存，那Session数据为什么不交给专业的缓存中间件呢？⽐如Redis

  优点:

  ​ 能适应各种负载均衡策略

  ​ 服务器重启或者宕机不会造成Session丢失

  ​ 扩展能⼒强

  ​ 适合⼤集群数量使⽤

  缺点：

  ​ 对应⽤有⼊侵，引⼊了和Redis的交互代码