一致性哈希算法

最新推荐文章于 2025-06-12 14:39:42 发布

原创最新推荐文章于 2025-06-12 14:39:42 发布 · 156 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#一致性哈希算法 #ConsistenceHashing #分布式缓存

分布式缓存专栏收录该内容

1 篇文章

订阅专栏

博客介绍了分布式缓存中请求转发问题，传统做法在增加主机时会导致大部分缓存失效、引发缓存雪崩。为解决该问题，需保证取余部分不变，将请求转发到映射位置后的第一台主机。此外，还给出了一致性哈希算法的Java代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

介绍

在分布式缓存中，每台缓存主机中存放的缓存数据不同，因此在读取缓存数据时，应该将请求正确转发到对应的缓存服务器。传统的做法是先给目标主机编号，如0~(N-1)，当收到请求时，计算请求标识符fid的哈希值fHash，之后将请求转发到fHash%N号的主机上。但当增加一台主机时，将会将请求转发到fHash%(N+1)的主机上，从而会使得大部分缓存失效，从而导致缓存雪崩。
为了解决该问题，只需要将取余部分不变，就能使得每次哈希计算结果不变。但是目标主机的哈希值可能和请求标识符的最终映射的位置不同，因此会转发到映射位置后的第一台主机上。

具体参考：原文链接

代码实现(Java)

生成唯一哈希值的接口及实现

public interface HashingFunc {
	public Long hash(Object key); 
}

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
public class ConcreteHashingFunc implements HashingFunc {
	@Override
	public Long hash(Object key) {
		return md5HashingAlg(key.toString());
	}
    /**
     * 使用MD5算法
     * @param key
     * @return
     */
    private long md5HashingAlg(String key) {
        MessageDigest md5 = null;
        try {
            md5 = MessageDigest.getInstance("MD5");
            md5.reset();
            md5.update(key.getBytes());
            byte[] bKey = md5.digest();
            long res = ((long) (bKey[3] & 0xFF) << 24) | ((long) (bKey[2] & 0xFF) << 16) | ((long) (bKey[1] & 0xFF) << 8)| (long) (bKey[0] & 0xFF);
            return res;
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return 0l;
    }
}

一致性哈希算法

import java.util.Collection;
import java.util.SortedMap;
import java.util.TreeMap;
/**
 * 一致性哈希函数，用来计算某个请求对应访问的主机号
 * @param <T>	主机类型
 */
public class ConsistenceHashing<T> {
	private HashingFunc hashingFunc;		//计算key的哈希值的接口
	private int copyNodeNum;				//每个结点对应的虚拟结点个数
	private SortedMap<Long, T> cicleMap = new TreeMap<Long , T>();
	/**
	 * 构造一致性Hashing对象
	 * @param hashingFunc	哈希函数
	 * @param copyNodeNum	每个结点对应的虚拟结点个数
	 * @param nodes			主机结点
	 */
	public ConsistenceHashing(HashingFunc hashingFunc,int copyNodeNum,Collection<T> nodes) {
		this.hashingFunc = hashingFunc;
		this.copyNodeNum = copyNodeNum;
		for (T t : nodes) {
			add(t);
		}
	}
	
	/**
	 * 增加主机结点
	 * @param node	主机结点
	 */
	public void add(T node){
		for (int i = 0; i < copyNodeNum; i++) {
			cicleMap.put(hashingFunc.hash(node.toString() + i), node);
		}
	}
	
	/**
	 * 获取当前请求对应的主机号
	 * @param kid	请求标识
	 * @return	
	 */
	public T get(Object kid){
		if(cicleMap.isEmpty()){
			return null;
		}
		Long kHash = hashingFunc.hash(kid);
		SortedMap<Long, T> tailMap = cicleMap.tailMap(kHash);		//获取key值大于等于kHash的部分	
		kHash = tailMap.isEmpty()?cicleMap.firstKey() : tailMap.firstKey();
		return cicleMap.get(kHash);
	}
	
	/**
	 * 移除目标主机
	 * @param node	主机结点
	 */
	public void remove(T node){
		for (int i = 0; i < copyNodeNum; i++) {
			cicleMap.remove(hashingFunc.hash(node.toString() + i));
		}
	}
}