一致性Hash演算法

雜湊表演算法 · 發表 2018-11-25 07:06:10

摘要：最近在做Redis方面的一些工作，其中Redis3.0以前的版本，伺服器端沒有提供叢集的方式。需要在客戶端做sharding。redis客戶端做sharding的話，需要用到一致性Hash演算法。假設我們有3臺redis伺服器。一、普通Hash演算法 1、首...

最近在做Redis方面的一些工作，其中Redis3.0以前的版本，伺服器端沒有提供叢集的方式。需要在客戶端做sharding。redis客戶端做sharding的話，需要用到一致性Hash演算法。

假設我們有3臺redis伺服器。

一、普通Hash演算法

1、首先對3臺redis伺服器的ip地址，進行hash運算。得到一個int型別的值。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;
}

2、利用得到的hash值對3進行取模

getHash(192.168.7.1)=196713682%3=1
getHash(192.168.7.2)=467665103%3=2
getHash(192.168.7.3)=542751888%3=0

3、假如我們想要把鍵值對name=linlin。存入到redis中，因為有3臺redis存在，所以必須要決定將鍵值對存入到哪一臺中。對key值name進行hash，然後對3進行取模。

getHash("name")=117328155%3=0

所以鍵值對name=linlin會被路由到192.168.7.3這臺伺服器中。

4、使用Java來實現

建立RedisNode類

package com.lin.hash.redis;

import java.util.HashMap;
import java.util.Map;

public class RedisNode {
private String ip;

private Map<String,Object> data;

public RedisNode(String ip) {
this.ip = ip;
data = new HashMap<>();
}
public String getIp() {
return ip;
}

public void setIp(String ip) {
this.ip = ip;
}

public Map<String, Object> getData() {
return data;
}

public void setData(Map<String, Object> data) {
this.data = data;
}

public Object getNodeValue(String key){
return data.get(key);
}
}

2.建立抽象類

package com.lin.hash.redis;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public abstract class RedisCluster {
protected List<RedisNode> redisNodes;


public RedisCluster() {
redisNodes = new ArrayList<>();
}

public List<RedisNode> getRedisNodes() {
return redisNodes;
}

public void setRedisNodes(List<RedisNode> redisNodes) {
this.redisNodes = redisNodes;
}


public abstract void addRedisNode(RedisNode redisNode);

public abstract RedisNode getRedisNode(String key);

public abstract void removeRedisNode(RedisNode redisNode);
}

3.建立NormalRedisCluster類

package com.lin.hash.redis;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

public class NormalRedisCluster extends RedisCluster {
private List<RedisNode> redisNodes;


public NormalRedisCluster() {
redisNodes = new ArrayList<>();
}

public List<RedisNode> getRedisNodes() {
return redisNodes;
}

public void setRedisNodes(List<RedisNode> redisNodes) {
this.redisNodes = redisNodes;
}


public void addRedisNode(RedisNode redisNode){
redisNodes.add(redisNode);
}

public RedisNode getRedisNode(String key){
int hash = HashUtils.getHash(key);
/**使用key的hash值對key進行取模*/
RedisNode redisNode = redisNodes.get(hash % redisNodes.size());
return redisNode;
}
public void removeRedisNode(RedisNode redisNode){
Iterator<RedisNode> iterator = redisNodes.iterator();
while (iterator.hasNext()){
RedisNode next = iterator.next();
if (next.getIp().equals(redisNode.getIp())){
iterator.remove();
}
}
}
}

4.建立HashUtils

package com.lin.hash.redis;

public class HashUtils {
/**
* 使用FNV1_32_HASH演算法計算伺服器的Hash值,這裡不使用重寫hashCode的方法，最終效果沒區別
*/
public 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;
}
}

5.建立RedisHashTest類

package com.lin.hash.redis;

import com.alibaba.fastjson.JSONObject;

import java.util.List;
import java.util.Map;

public class RedisHashTest {
public static void main(String[] args) {
String[] servers = {"192.168.7.1","192.168.7.2","192.168.7.3"};

/**
* 新增redis節點
*/
RedisCluster redisCluster = new NormalRedisCluster();
for (String server:servers){
redisCluster.addRedisNode(new RedisNode(server));
}

/**
* 往redis叢集中加入100條資料
* */

int dataCount = 100;

for (int i=0;i<dataCount;i++){
String key = "name"+i;
String value = "linlin"+i;

/**獲取節點*/
RedisNode redisNode = redisCluster.getRedisNode(key);
Map<String, Object> data = redisNode.getData();
data.put(key,value);
}

/**獲取redis節點中的資料分佈*/
List<RedisNode> redisNodes = redisCluster.getRedisNodes();
for (RedisNode redisNode:redisNodes){
System.out.println(JSONObject.toJSONString(redisNode.getData()));
}

/**檢視節點不變的情況下，redis資料的命中率*/
int hitCount = 0;
for (int i=0;i<dataCount;i++){
String key = "name"+i;
String value = "linlin"+i;
Object nodeValue = redisCluster.getRedisNode(key).getNodeValue(key);
if (nodeValue != null){
hitCount++;
}
}

System.out.println("資料命中率為："+hitCount*1.0/dataCount);

/**新增一個節點的情況下資料的命中率*/
redisCluster.addRedisNode(new RedisNode("192.168.7.4"));
hitCount=0;
for (int i=0;i<dataCount;i++){
String key = "name"+i;
String value = "linlin"+i;
Object nodeValue = redisCluster.getRedisNode(key).getNodeValue(key);
if (nodeValue != null){
hitCount++;
}
}
System.out.println("新增節點的情況下，redis資料的命中率:"+hitCount*1.0/dataCount);

///**刪除一個節點的情況下資料的命中率*/
//normalRedisCluster.removeRedisNode(new RedisNode("192.168.7.2"));
//hitCount=0;
//for (int i=0;i<dataCount;i++){
//String key = "name"+i;
//String value = "linlin"+i;
//Object nodeValue = normalRedisCluster.getRedisNode(key).getNodeValue(key);
//if (nodeValue != null){
//hitCount++;
//}
//}
//System.out.println("刪除節點的情況下，redis資料的命中率:"+hitCount*1.0/dataCount);
}
}

5.我們可以看到在節點保持不變的情況下，資料的命中率為1.0。

新增一個節點的命中率為：0.27

刪除一個節點的命中率為：0.4

但是無論是新增一個節點或者刪除一個節點。資料的命中率都會顯著降低。