一致性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函数，可以推荐哈。

巴特西

一致性hash演示

最新文章

热门文章