mysql 一致性hash_一致性hash算法在分表分库中的应用

一致性hash算法结构图

分表分库结构图

可进行循环冗余存储，顺时针存储到下一个物理节点(非虚拟节点)

package com.haiziwang.platform.kmcsms.route.algorithm;

import java.util.Collection;

import java.util.SortedMap;

import java.util.TreeMap;

/**

* 一致性Hash算法

* 算法详解：http://blog.csdn.net/sparkliang/article/details/5279393

* 算法实现：https://weblogs.java.net/blog/2007/11/27/consistent-hashing

*

* @param 节点类型,比如ip或host等

* @author xiaoleilu

*/

public class ConsistentHash {

/**

* Hash计算对象，用于自定义hash算法

*/

HashFunc hashFunc;

/**

* 复制的节点个数

*/

private final int numberOfReplicas;

/**

* 一致性Hash环

*/

private final SortedMap circle = new TreeMap();

/**

* 构造，使用Java默认的Hash算法

*

* @param numberOfReplicas 复制的节点个数，增加每个节点的复制节点有利于负载均衡

* @param nodes 节点对象

*/

public ConsistentHash(int numberOfReplicas, Collection nodes) {

this.numberOfReplicas = numberOfReplicas;

this.hashFunc = new HashFunc() {

@Override

public Integer hash(Object key) {

String data = key.toString();

//默认使用FNV1hash算法

final int p = 16777619;

int hash = (int) 2166136261L;

for (int i = 0; i < data.length(); i++)

hash = (hash ^ data.charAt(i)) * p;

hash += hash << 13;

hash ^= hash >> 7;

hash += hash << 3;

hash ^= hash >> 17;

hash += hash << 5;

return hash;

}

};

//初始化节点

for (T node : nodes) {

add(node);

}

}

/**

* 构造

*

* @param hashFunc hash算法对象

* @param numberOfReplicas 复制的节点个数，增加每个节点的复制节点有利于负载均衡

* @param nodes 节点对象

*/

public ConsistentHash(HashFunc hashFunc, int numberOfReplicas, Collection nodes) {

this.numberOfReplicas = numberOfReplicas;

this.hashFunc = hashFunc;

//初始化节点

for (T node : nodes) {

add(node);

}

}

/**

* 增加节点

* 每增加一个节点，就会在闭环上增加给定复制节点数

* 例如复制节点数是2，则每调用此方法一次，增加两个虚拟节点，这两个节点指向同一Node

* 由于hash算法会调用node的toString方法，故按照toString去重

*

* @param node 节点对象

*/

public void add(T node) {

for (int i = 0; i < numberOfReplicas; i++) {

circle.put(hashFunc.hash(node.toString() + i), node);

}

}

/**

* 移除节点的同时移除相应的虚拟节点

*

* @param node 节点对象

*/

public void remove(T node) {

for (int i = 0; i < numberOfReplicas; i++) {

circle.remove(hashFunc.hash(node.toString() + i));

}

}

/**

* 获得一个最近的顺时针节点

*

* @param key 为给定键取Hash，取得顺时针方向上最近的一个虚拟节点对应的实际节点

* @return 节点对象

*/

public T get(Object key) {

if (circle.isEmpty()) {

return null;

}

int hash = hashFunc.hash(key);

if (!circle.containsKey(hash)) {

SortedMap tailMap = circle.tailMap(hash); //返回此映射的部分视图，其键大于等于 hash

hash = tailMap.isEmpty() ? circle.firstKey() : tailMap.firstKey();

}

//正好命中

return circle.get(hash);

}

/**

* Hash算法对象，用于自定义hash算法

*

* @author xiaoleilu

*/

public interface HashFunc {

public Integer hash(Object key);

}

}

package com.haiziwang.platform.kmcsms.route.demo;

/**

* Created by wangzhongbao on 2016/12/14.

*/

public class NodeBean {

private String dbIp;

public NodeBean(String dbIp) {

this.dbIp = dbIp;

}

public String getDbIp() {

return dbIp;

}

@Override

public String toString() {

return dbIp;

}

/*@Override

public boolean equals(Object obj) {

return this.toString().equals(obj.toString());

}

@Override

public int hashCode() {

return 1;

}*/

}

package com.haiziwang.platform.kmcsms.route.demo;

/**

* Created by wangzhongbao on 2016/12/14.

*/

public class TelUtil {

private static String[] telFirst="134,135,136,137,138,139,150,151,152,157,158,159,130,131,132,155,156,133,153".split(",");

public static String getTel() {

int index= getNum(0,telFirst.length-1);

String first=telFirst[index];

String second=String.valueOf(getNum(1,10000)+10000).substring(1);

String thrid=String.valueOf(getNum(1,10000)+10000).substring(1);

return first+second+thrid;

}

private static int getNum(int start,int end) {

return (int)(Math.random()*(end-start+1)+start);

}

}

package com.haiziwang.platform.kmcsms.route.demo;

import com.haiziwang.platform.kmcsms.route.algorithm.ConsistentHash;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

/**

* Created by wangzhongbao on 2016/12/14.

*/

public class Sample {

public static void main(String[] args) {

//每个节点虚拟出来的节点数

final int numberOfReplicas = 10000;

List nodeList = new ArrayList();

nodeList.add(new NodeBean("000"));

nodeList.add(new NodeBean("111"));

nodeList.add(new NodeBean("222"));

nodeList.add(new NodeBean("333"));

nodeList.add(new NodeBean("444"));

nodeList.add(new NodeBean("555"));

nodeList.add(new NodeBean("666"));

nodeList.add(new NodeBean("777"));

nodeList.add(new NodeBean("888"));

nodeList.add(new NodeBean("999"));

ConsistentHash stringConsistentHash = new ConsistentHash(numberOfReplicas,nodeList);

Map countMap = new HashMap(){

@Override

public Integer put(NodeBean key, Integer value) {

Integer oldVal = this.get(key);

if(oldVal==null){

return super.put(key, value);

}else{

return super.put(key,oldVal+1);

}

}

};

long l = System.currentTimeMillis();

for(int i=0;i<1000000;i++){

NodeBean nodeBean = stringConsistentHash.get(TelUtil.getTel());

countMap.put(nodeBean, 1);

}

System.out.println("1000000计算耗时："+(System.currentTimeMillis() - l)+"毫秒");

for(NodeBean nb:countMap.keySet()){

System.out.println(nb.toString()+" 分配到个数："+countMap.get(nb));

}

}

}