一致性 hash算法

面试被鄙视了 只能好好地学习了

 

一致性哈希算法，
   一致性哈希算法主要是解决分布式缓存中对于增加删除节点而导致的缓存失效的问题，
   这对比普通的hash缓存，我们通常在固定节点N的缓存服务器上是这样分配缓存的  hash（K）%N  这样，我们每次取缓存的时候都是按照N这个来取摸的，当N变成N+1或者其他，那我们所有的缓存就都失效了。这时候就要说一致性hash了
    一致性hash 算法主要是先把服务器给hash了，hash（server） 这样服务器就均匀的分布了（这里要加虚拟节点），然后我们再把hash（K）来和这些比较 ，看到在这个范围就放到结点里面，（其实都是数组的比较了，，因为hash算出来是一个2的32次方的数，然后服务器的hash就是一个一个的结点，K的hash就就和这些结点比较，然后在范围就放到一个节点里面）

   我理解的理论应该就是这样，那代码呢，代码在哪里

 

   import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.SortedMap;
import java.util.TreeMap;

 

 

public class MyHash {

 
 private static TreeMap<Long, Node> treeMap;
 private static List<Node> list = new ArrayList<>();
 
 public MyHash(List<Node> list ){
  super();
  this.list = list;
  init();
 }
 public void init(){
  treeMap = new TreeMap<>();
  for(int i=0;i<list.size();i++){
   Node node  = list.get(i);
   treeMap.put(hash("SHARD-" + node.name + "-NODE-" + node.ip), node);
  }
 }
 
 
 public void putintoNode(String key){
  SortedMap<Long, Node> sort = treeMap.tailMap(hash(key));
  if (sort.size() == 0) {
   return;
  }
  treeMap.put(hash(key), sort.get(sort.firstKey()));
  
 }
 
 //添加一个虚拟节点进环形结构,lg为虚拟节点的hash值
  public void addS(Node s){
   /*Long ha = hash("SHARD-" + s.name + "-NODE-"+s.ip);
   SortedMap<Long, Node> tail = treeMap.tailMap(ha);
   SortedMap<Long,Node>  head = treeMap.headMap(ha);
   
   SortedMap<Long,Node> between;
   if(head.size()==0){
    
   }*/
   treeMap.put(hash("SHARD-" + s.name + "-NODE-"+s.ip), s);   
  }
  
 /**
  *  MurMurHash算法，是非加密HASH算法，性能很高，
  *  比传统的CRC32,MD5，SHA-1（这两个算法都是加密HASH算法，复杂度本身就很高，带来的性能上的损害也不可避免）
  *  等HASH算法要快很多，而且据说这个算法的碰撞率很低.
  *  http://murmurhash.googlepages.com/
  */
 private static Long hash(String key) {
  
  ByteBuffer buf = ByteBuffer.wrap(key.getBytes());
  int seed = 0x1234ABCD;
  
  ByteOrder byteOrder = buf.order();
        buf.order(ByteOrder.LITTLE_ENDIAN);

        long m = 0xc6a4a7935bd1e995L;
        int r = 47;

        long h = seed ^ (buf.remaining() * m);

        long k;
        while (buf.remaining() >= 8) {
            k = buf.getLong();

            k *= m;
            k ^= k >>> r;
            k *= m;

            h ^= k;
            h *= m;
        }

        if (buf.remaining() > 0) {
            ByteBuffer finish = ByteBuffer.allocate(8).order(
                    ByteOrder.LITTLE_ENDIAN);
            // for big-endian version, do this first:
            // finish.position(8-buf.remaining());
            finish.put(buf).rewind();
            h ^= finish.getLong();
            h *= m;
        }

        h ^= h >>> r;
        h *= m;
        h ^= h >>> r;

        buf.order(byteOrder);
        return h;
 }
 
 static class Node{
  String name;
  String ip;
  public Node(String name,String ip) {
   this.name = name;
   this.ip = ip;
  }
  @Override
  public String toString() {
   return this.name+"-"+this.ip;
  }
 }
}