hash一致性分析

先来个介绍    

哈希算法 
    一致性哈希提出了在动态变化的Cache环境中，哈希算法应该满足的4个适应条件： 

平衡性(Balance) 
平衡性是指哈希的结果能够尽可能分布到所有的缓冲中去，这样可以使得所有的缓冲空间都得到利用。很多哈希算法都能够满足这一条件。 

单调性(Monotonicity) 
单调性是指如果已经有一些内容通过哈希分派到了相应的缓冲中，又有新的缓冲区加入到系统中，那么哈希的结果应能够保证原有已分配的内容可以被映射到新的缓冲区中去，而不会被映射到旧的缓冲集合中的其他缓冲区。（这段翻译信息有负面价值的，当缓冲区大小变化时Consistent hashing尽量保护已分配的内容不会被重新映射到新缓冲区。） 
简单的哈希算法往往不能满足单调性的要求，如最简单的线性哈希： 
x → ax + b mod (P) 
在上式中，P表示全部缓冲的大小。不难看出，当缓冲大小发生变化时(从P1到P2)，原来所有的哈希结果均会发生变化，从而不满足单调性的要求。 
哈希结果的变化意味着当缓冲空间发生变化时，所有的映射关系需要在系统内全部更新。而在P2P系统内，缓冲的变化等价于Peer加入或退出系统，这一情况在P2P系统中会频繁发生，因此会带来极大计算和传输负荷。单调性就是要求哈希算法能够应对这种情况。 

分散性(Spread) 
在分布式环境中，终端有可能看不到所有的缓冲，而是只能看到其中的一部分。当终端希望通过哈希过程将内容映射到缓冲上时，由于不同终端所见的缓冲范围有可能不同，从而导致哈希的结果不一致，最终的结果是相同的内容被不同的终端映射到不同的缓冲区中。这种情况显然是应该避免的，因为它导致相同内容被存储到不同缓冲中去，降低了系统存储的效率。分散性的定义就是上述情况发生的严重程度。好的哈希算法应能够尽量避免不一致的情况发生，也就是尽量降低分散性。 

负载(Load) 
负载问题实际上是从另一个角度看待分散性问题。既然不同的终端可能将相同的内容映射到不同的缓冲区中，那么对于一个特定的缓冲区而言，也可能被不同的用户映射为不同的内容。与分散性一样，这种情况也是应当避免的，因此好的哈希算法应能够尽量降低缓冲的负荷。 

结论 
    一致性哈希基本解决了在P2P环境中最为关键的问题——如何在动态的网络拓扑中分布存储和路由。每个节点仅需维护少量相邻节点的信息，并且在节点加入/退出系统时，仅有相关的少量节点参与到拓扑的维护中。所有这一切使得一致性哈希成为第一个实用的DHT算法。 
    但是一致性哈希的路由算法尚有不足之处。在查询过程中，查询消息要经过O(N)步(O(N)表示与N成正比关系，N代表系统内的节点总数)才能到达被查询的节点。不难想象，当系统规模非常大时，节点数量可能超过百万，这样的查询效率显然难以满足使用的需要。换个角度来看，即使用户能够忍受漫长的时延，查询过程中产生的大量消息也会给网络带来不必要的负荷。

直接上代码

package testhash;

import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.Scanner;
import java.util.SortedMap;
import java.util.TreeMap;




public class ConsistencyHash {



private TreeMap<Long,Object> nodes = null;   
    //真实服务器节点信息   
    private List<Object> shards = new ArrayList();   
    //设置虚拟节点数目   
    private int VIRTUAL_NUM = 4;   
  
    /**  
     * 初始化一致环  
     */  
    public void init() {   
         shards.add("192.168.0.0-服务器");   
         shards.add("192.168.0.1-服务器");   
         shards.add("192.168.0.2-服务器");   
         shards.add("192.168.0.3-服务器");   
         shards.add("192.168.0.4-服务器");   
  
        nodes = new TreeMap<Long,Object>();   
        for(int i=0; i<shards.size(); i++) {   
            Object shardInfo = shards.get(i);   
            for(int j=0; j<VIRTUAL_NUM; j++) {   
                nodes.put(hash(computeMd5("SHARD-" + i + "-NODE-" + j),j), shardInfo);   
            }   
        }   
    }   
  
    /**  
     * 根据key的hash值取得服务器节点信息  
     * @param hash  
     * @return  
     */  
    public Object getShardInfo(long hash) {   
        Long key = hash;   
        SortedMap<Long, Object> tailMap=nodes.tailMap(key);   
        if(tailMap.isEmpty()) {   
            key = nodes.firstKey();   
        } else {   
            key = tailMap.firstKey();   
        }   
        return nodes.get(key);   
    }  
    
    public String GetPrimary(String k){
        byte[] digest = computeMd5(k);
        String rv = getNodeForKey(hash(digest, 0));
        return rv;
      }
      
      
      public String getNodeForKey(long hash) {
          String rv;
          if (!nodes.containsKey(hash)) {
            SortedMap<Long, Object> tailMap = getKetamaNodes().tailMap(hash);
            if (tailMap.isEmpty()) {
              hash = getKetamaNodes().firstKey();
            } else {
              hash = tailMap.firstKey();
            }
          }
          rv = getKetamaNodes().get(hash).toString();
          return rv;
      }
      
      protected TreeMap<Long, Object> getKetamaNodes() {
          return nodes;
       }
  
    /**  
     * 打印圆环节点数据  
     */  
     public void printMap() {   
         System.out.println(nodes);   
     }   
  
    /**  
     * 根据2^32把节点分布到圆环上面。  
     * @param digest  
     * @param nTime  
     * @return  
     */  
      public long hash(byte[] digest, int nTime) {   
        long rv = ((long) (digest[3+nTime*4] & 0xFF) << 24)   
                | ((long) (digest[2+nTime*4] & 0xFF) << 16)   
                | ((long) (digest[1+nTime*4] & 0xFF) << 8)   
                | (digest[0+nTime*4] & 0xFF);   
  
        return rv & 0xffffffffL; /* Truncate to 32-bits */  
      }   
  
    /**  
     * Get the md5 of the given key.  
     * 计算MD5值  
     */  
     public byte[] computeMd5(String k) {   
        MessageDigest md5;   
        try {   
            md5 = MessageDigest.getInstance("MD5");   
        } catch (NoSuchAlgorithmException e) {   
            throw new RuntimeException("MD5 not supported", e);   
        }   
        md5.reset();   
        byte[] keyBytes = null;   
        try {   
            keyBytes = k.getBytes("UTF-8");   
        } catch (UnsupportedEncodingException e) {   
            throw new RuntimeException("Unknown string :" + k, e);   
        }   
  
        md5.update(keyBytes);   
        return md5.digest();   
     }   
  
     public static void main(String[] args) {   
         Random ran = new Random();   
         ConsistencyHash hash = new ConsistencyHash();   
         hash.init();   
         //hash.printMap();   
         //循环50次，是为了取50个数来测试效果，当然也可以用其他任何的数据来测试   
         for(int i=0; i<10; i++) {   
             System.out.println(i+"被分到:"+hash.getShardInfo(hash.hash(hash.computeMd5(String.valueOf(i)),0)));   
         }  
         
         Scanner scanner=new Scanner(System.in);
         while(scanner.hasNext()){
        int value=scanner.nextInt();
        System.out.println("key:"+value+"  所在的服务器是"+hash.getShardInfo(hash.hash(hash.computeMd5(String.valueOf(value)),0)));
         }
   }   
}