目前我们很多时候都是在做分布式系统,但是我们需把客户端的请求均匀的分布到N个服务器中,一般我们可以考虑通过Object的HashCodeHash%N,通过取余,将客户端的请求分布到不同的的服务端。但是在分布式集群中我们通常需要添加或删除服务器,所以通过取余是不行的。一致性Hash就是为了解决这个问题。

  Consistent Hashing 一致性Hash的原理

  1、环型Hash空间

  根据常用的Hash,是将key哈希到一个长为2^32的桶中,即0~2^32-1的数字空间,最后通过首尾相连,我们可以想象成一个闭合的圆。如图:

  

  2、把数据通过一定的Hash算法处理后,映射到环上

  例如:我们有Object1、Object2、Object3、Object4,通过Hash算法求出值如下:

    Hash(Object1) = key1;

    Hash(Object2) = key2;

    Hash(Object3) = key3;

    Hash(Object4) = key4;

  

  3、将机器信息通过hash算法映射到环上

    一般情况下是对机器的信息通过计算hash,然后以顺时针方向计算,将对象信息存储在相应的位置。

    

  4、虚拟节点

    上面是Hash算法的特性,但是Hash算法缺少一个平衡性。

    Hash算法的平衡行就是为了尽可能使分配到每个数据桶里面的节点是均衡的,一个简单的例子:我们有3个分布式服务器,在大量客户端访问时,通过Hash算法,使得他们能在每个服务器均匀的访问。所以这里引入了“虚拟节点”节点,从而保证数据节点均衡。

    “虚拟节点”就是真实节点的复制品,一个真实的节点对应多个“虚拟节点”,这样使得我们的节点能尽可能的在环形Hash空间均匀分布,这样我们再根据虚拟节点找到真实节点,从而保证每个真实节点上分配到的请求是均衡的。

    

  具体的代码实现如下:  

import java.util.LinkedList;
import java.util.List;
import java.util.SortedMap;
import java.util.TreeMap; public class ConsistencyHashing { // 虚拟节点的个数
private static final int VIRTUAL_NUM = 5; // 虚拟节点分配,key是hash值,value是虚拟节点服务器名称
private static SortedMap<Integer, String> shards = new TreeMap<Integer, String>(); // 真实节点列表
private static List<String> realNodes = new LinkedList<String>(); //模拟初始服务器
private static String[] servers = { "192.168.1.1", "192.168.1.2", "192.168.1.3", "192.168.1.5", "192.168.1.6" }; static {
for (String server : servers) {
realNodes.add(server);
System.out.println("真实节点[" + server + "] 被添加");
for (int i = 0; i < VIRTUAL_NUM; i++) {
String virtualNode = server + "&&VN" + i;
int hash = getHash(virtualNode);
shards.put(hash, virtualNode);
System.out.println("虚拟节点[" + virtualNode + "] hash:" + hash + ",被添加");
}
}
} /**
* 获取被分配的节点名
*
* @param node
* @return
*/
public static String getServer(String node) {
int hash = getHash(node);
Integer key = null;
SortedMap<Integer, String> subMap = shards.tailMap(hash);
if (subMap.isEmpty()) {
key = shards.lastKey();
} else {
key = subMap.firstKey();
}
String virtualNode = shards.get(key);
return virtualNode.substring(0, virtualNode.indexOf("&&"));
} /**
* 添加节点
*
* @param node
*/
public static void addNode(String node) {
if (!realNodes.contains(node)) {
realNodes.add(node);
System.out.println("真实节点[" + node + "] 上线添加");
for (int i = 0; i < VIRTUAL_NUM; i++) {
String virtualNode = node + "&&VN" + i;
int hash = getHash(virtualNode);
shards.put(hash, virtualNode);
System.out.println("虚拟节点[" + virtualNode + "] hash:" + hash + ",被添加");
}
}
} /**
* 删除节点
*
* @param node
*/
public static void delNode(String node) {
if (realNodes.contains(node)) {
realNodes.remove(node);
System.out.println("真实节点[" + node + "] 下线移除");
for (int i = 0; i < VIRTUAL_NUM; i++) {
String virtualNode = node + "&&VN" + i;
int hash = getHash(virtualNode);
shards.remove(hash);
System.out.println("虚拟节点[" + virtualNode + "] hash:" + hash + ",被移除");
}
}
} /**
* FNV1_32_HASH算法
*/
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[] nodes = { "127.0.0.1", "10.9.3.253", "192.168.10.1" }; for (String node : nodes) {
System.out.println("[" + node + "]的hash值为" + getHash(node) + ", 被路由到结点[" + getServer(node) + "]");
} // 添加一个节点(模拟服务器上线)
addNode("192.168.1.7");
// 删除一个节点(模拟服务器下线)
delNode("192.168.1.2"); for (String node : nodes) {
System.out.println("[" + node + "]的hash值为" + getHash(node) + ", 被路由到结点[" + getServer(node) + "]");
}
}
}

  测试结果:

  

  从结果可以看出:服务器节点上线和下线并不会对我们服务有任何影响,除非所有的服务都下线。

          当之前映射的服务器下线,我们可以切换到和它Hash临近的服务节点上,保证服务的负载均衡。

          如果我们考虑没太服务器性能不一致,比如服务器内存有32G、16G、8G的,我们可以根据不同的服务器性能,分配不同的负载因子(就是上面程序的VIRTUAL_NUM),这样我们是不是可以想到和Dubbo里面的负载因子是一致的,我们可以手动的调整每台服务器的负载因子,从而控制根据每个服务器性能,分配不同权重的客户端请求负载量,就是俗话说的“吃多少饭,干多少活” 。

  实现案例:

  

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.SortedMap;
import java.util.TreeMap; public class ConsistencyHashingLoadFactor { // 真实节点列表
private static List<Machine> realNodes = new ArrayList<Machine>(); // 虚拟节点,key是Hash值,value是虚拟节点信息
private static SortedMap<Integer, String> shards = new TreeMap<Integer, String>(); static {
realNodes.add(new Machine("192.168.1.1", LoadFactor.Memory8G));
realNodes.add(new Machine("192.168.1.2", LoadFactor.Memory16G));
realNodes.add(new Machine("192.168.1.3", LoadFactor.Memory32G));
realNodes.add(new Machine("192.168.1.4", LoadFactor.Memory16G));
for (Machine node : realNodes) {
for (int i = 0; i < node.getMemory().getVrNum(); i++) {
String server = node.getHost();
String virtualNode = server + "&&VN" + i;
int hash = getHash(virtualNode);
shards.put(hash, virtualNode);
}
}
} /**
* 获取被分配的节点名
*
* @param node
* @return
*/
public static Machine getServer(String node) {
int hash = getHash(node);
Integer key = null;
SortedMap<Integer, String> subMap = shards.tailMap(hash);
if (subMap.isEmpty()) {
key = shards.lastKey();
} else {
key = subMap.firstKey();
}
String virtualNode = shards.get(key);
String realNodeName = virtualNode.substring(0, virtualNode.indexOf("&&"));
for (Machine machine : realNodes) {
if (machine.getHost().equals(realNodeName)) {
return machine;
}
}
return null;
} /**
* 添加节点
*
* @param node
*/
public static void addNode(Machine node) {
if (!realNodes.contains(node)) {
realNodes.add(node);
System.out.println("真实节点[" + node + "] 上线添加");
for (int i = 0; i < node.getMemory().getVrNum(); i++) {
String virtualNode = node.getHost() + "&&VN" + i;
int hash = getHash(virtualNode);
shards.put(hash, virtualNode);
System.out.println("虚拟节点[" + virtualNode + "] hash:" + hash + ",被添加");
}
}
} /**
* 删除节点
*
* @param node
*/
public static void delNode(Machine node) {
String host = node.getHost();
Iterator<Machine> it = realNodes.iterator();
while(it.hasNext()) {
Machine machine = it.next();
if(machine.getHost().equals(host)) {
it.remove();
System.out.println("真实节点[" + node + "] 下线移除");
for (int i = 0; i < node.getMemory().getVrNum(); i++) {
String virtualNode = node.getHost() + "&&VN" + i;
int hash = getHash(virtualNode);
shards.remove(hash);
System.out.println("虚拟节点[" + virtualNode + "] hash:" + hash + ",被移除");
}
}
}
} /**
* FNV1_32_HASH算法
*/
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[] nodes = { "127.0.0.1", "10.9.3.253", "192.168.10.1" }; for (String node : nodes) {
System.out.println("[" + node + "]的hash值为" + getHash(node) + ", 被路由到结点[" + getServer(node) + "]");
} // 添加一个节点(模拟服务器上线)
addNode(new Machine("192.168.1.7", LoadFactor.Memory16G));
// 删除一个节点(模拟服务器下线)
delNode(new Machine("192.168.1.1", LoadFactor.Memory8G)); for (String node : nodes) {
System.out.println("[" + node + "]的hash值为" + getHash(node) + ", 被路由到结点[" + getServer(node) + "]");
}
}
} /**
* 机器类
*
* @author yangkuanjun
*
*/
class Machine { private String host; private LoadFactor memory; public String getHost() {
return host;
} public void setHost(String host) {
this.host = host;
} public LoadFactor getMemory() {
return memory;
} public void setMemory(LoadFactor memory) {
this.memory = memory;
} public Machine(String host, LoadFactor memory) {
super();
this.host = host;
this.memory = memory;
} @Override
public String toString() {
return "Machine [host=" + host + ", memory=" + memory + "]";
}
} /**
* 负载因子
*
* @author yangkuanjun
*
*/
enum LoadFactor { Memory8G(5), Memory16G(10), Memory32G(20); private int vrNum; private LoadFactor(int vrNum) {
this.vrNum = vrNum;
} public int getVrNum() {
return vrNum;
} }

  测试结果:

  

  从运行结果可以看出:负载因子较大的被分配的概率就越大。

 

Java 一致性Hash算法的学习的更多相关文章

  1. 对一致性Hash算法,Java代码实现的深入研究

    一致性Hash算法 关于一致性Hash算法,在我之前的博文中已经有多次提到了,MemCache超详细解读一文中"一致性Hash算法"部分,对于为什么要使用一致性Hash算法.一致性 ...

  2. Java实现一致性Hash算法深入研究

    一致性Hash算法 关于一致性Hash算法,在我之前的博文中已经有多次提到了,MemCache超详细解读一文中”一致性Hash算法”部分,对于为什么要使用一致性Hash算法和一致性Hash算法的算法原 ...

  3. 【转载】对一致性Hash算法,Java代码实现的深入研究

    原文地址:http://www.cnblogs.com/xrq730/p/5186728.html 一致性Hash算法 关于一致性Hash算法,在我之前的博文中已经有多次提到了,MemCache超详细 ...

  4. 一致性Hash算法原理,java实现,及用途

    学习记录: 一致性Hash算法原理及java实现:https://blog.csdn.net/suifeng629/article/details/81567777 一致性Hash算法介绍,原理,及使 ...

  5. 一致性hash算法及java实现

    一致性hash算法是分布式中一个常用且好用的分片算法.或者数据库分库分表算法.现在的互联网服务架构中,为避免单点故障.提升处理效率.横向扩展等原因,分布式系统已经成为了居家旅行必备的部署模式,所以也产 ...

  6. 对一致性Hash算法及java实现(转)

    一致性Hash算法 关于一致性Hash算法,在我之前的博文中已经有多次提到了,MemCache超详细解读一文中"一致性Hash算法"部分,对于为什么要使用一致性Hash算法.一致性 ...

  7. 对一致性Hash算法,Java代码实现的深入研究(转)

    转载:http://www.cnblogs.com/xrq730/p/5186728.html 一致性Hash算法 关于一致性Hash算法,在我之前的博文中已经有多次提到了,MemCache超详细解读 ...

  8. 【策略】一致性Hash算法(Hash环)的java代码实现

    [一]一致性hash算法,基本实现分布平衡. package org.ehking.quartz.curator; import java.util.SortedMap; import java.ut ...

  9. Java实现一致性Hash算法

    Java代码实现了一致性Hash算法,并加入虚拟节点.,具体代码为: package com.baijob.commonTools;   import java.util.Collection; im ...

随机推荐

  1. Atitit &#160;图像处理Depixelizing&#160;Pixel&#160;Art像素风格画的矢量化

    Atitit  图像处理Depixelizing Pixel Art像素风格画的矢量化 在去年的时候,偶然看到hqx算法. 一个高质量的插值放大算法. 与双线性插值等插值算法相比,这个算法放大后对人眼 ...

  2. popoverPresentationController UIPopoverController 使用方法详解

    之前iPad特有的控件,现在iPhone亦可使用. 点击按钮,弹出popOverVC. 按钮的点击事件: - (IBAction)pickOrderAction:(UIButton *)sender ...

  3. mac

    command+R 刷新页面 command+shift+C 我的电脑 finder->应用程序 -> 实用程序 -> 终端 打开 cmd command+F3 显示桌面 comma ...

  4. C语言数据类型取值范围

    一.获取数据类型在系统中的位数 在不同的系统中,数据类型的字节数(bytes)不同,位数(bits)也有所不同,那么对应的取值范围也就有了很大的不同,那我们怎么知道你当前的系统中C语言的某个数据类型的 ...

  5. struts2框架——从后台取得数据集,并在前台页面循环显示

    1.CourseBean.java public class CourseBean { private String f_courseId = ""; private String ...

  6. .NET中的Queue和Stack

    1.ArrayList类 ArrayList类主要用于对一个数组中的元素进行各种处理.在ArrayList中主要使用Add.Remove.RemoveAt.Insert四个方法对栈进行操作.Add方法 ...

  7. Dev-C++之开启装逼效果

    Dev-C++是个不错的C++IDE——在10年前,它是很不错,在现在,它是个以界面丑陋和调试像吃粑粑这两点著称,如下图.

  8. Vxworks、QNX、Xenomai、Intime、Sylixos、Ucos等实时操作系统的性能特点

    Vxworks.QNX.Xenomai.Intime.Sylixos.Ucos等实时操作系统的性能特点 VxWorks操作系统 VxWorks 操作系统是美国WindRiver公司于1983年设计开发 ...

  9. centos 6.4 x64安装bugfree

    第一步:下载xampp-linux-1.8.1.tar.gz [root@SVNMANAGER ~]# tar -zxvf xampp-linux-1.8.1.tar.gz -C /opt [root ...

  10. 51 nod 1055 最长等差数列(dp)

    1055 最长等差数列 基准时间限制:2 秒 空间限制:262144 KB 分值: 80 难度:5级算法题 N个不同的正整数,找出由这些数组成的最长的等差数列.     例如:1 3 5 6 8 9 ...