一致性hash演示

看到点关于一致性hash的说明，觉得挺有意思，就想体验一下。

上代码看看，体会一下在一致性hash环境下的cache和获取。

因为是小代码演示，没有很细致，包括hash函数就是用取余操作，但活生生的显示出来一致性hash环境下，增减服务器对hash分布的影响（关于这个演示，要靠手工尝试）。

 package com.test.algorithms;

 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Set;

 public class ConsistentHash {

     private static final int CYCLE_SIZE = 128;

     public static void main(String[] args){
         Machine[] machines = new Machine[]{//new Machine("cache-server-1", "192.168.10.10"),
                                             new Machine("cache-server-2", "192.168.10.11"),
                 new Machine("cache-server-3", "192.168.10.12"),
                 new Machine("cache-server-4", "192.168.10.13")
         };

         for(Machine m : machines){
             m.setHashOrder(hash(m.hashCode()));
         }
         Arrays.sort(machines);

         for(int j=1; j<10000; j+=17){
             String cacheThing = "cache"+j;
             int hash = hash(cacheThing.hashCode());
             if(hash < 0 ){
                 hash = -1 * hash;
             }
 //            System.out.println(cacheThing+" == "+hash+" == "+cacheThing.hashCode());
             for(int i=0, size = machines.length;i<size;i++){
                 if(hash <= machines[i].getHashOrder()){
                     machines[i].addToCache(cacheThing);
                     break;
                 } else if(i == size-1){
                     machines[0].addToCache(cacheThing);
                     break;
                 }
             }
         }

         for(Machine m : machines){
             System.out.println(m);
         }
     }

     public static int hash(int input){
         return input % CYCLE_SIZE;
     }

     public static class Machine implements Comparable<Machine>{
         private String ip;
         private String name;
         private int hashOrder;

         private Set<String> cache = new HashSet<String>();

         public Machine(String name, String ip){
             this.name = name;
             this.ip = ip;
         }

         public void setHashOrder(int hashOrder){
             this.hashOrder = hashOrder;
         }

         public void addToCache(String thing){
             this.cache.add(thing);
         }

         public Set<String> getCache(){
             return this.cache;
         }

         @Override
         public int compareTo(Machine o) {
             return this.hashOrder - o.hashOrder;
         }

         public int getHashOrder(){
             return this.hashOrder;
         }

         @Override
         public int hashCode(){
             int rs = 17;
             rs = 31*rs + ip.hashCode();
             rs = 31*rs + name.hashCode();
             return rs;
         }

         @Override
         public String toString() {
             return "Machine{" +
                     "ip='" + ip + '\'' +
                     ", name='" + name + '\'' +
                     ", hashOrder=" + hashOrder +
                     ", cache size=" + this.cache.size()+
 //                    ", cache=" + cache +
                     '}';
         }
     }

 }

运行之后，可以看到各个machine里面有多少个cache值，也就是看看分布情况，如果分布不理想，可以通过调整cycle_size来影响。

我测试了128，256，512，1024，发现128最均匀。其实这个东西的关键就是hash函数。

有好的hash函数，可以推荐哈。