Java实现一致性哈希算法，并搭建环境测试其负载均衡特性。

public class ConsistentHashTest {
    /**
     * 服务器列表,一共有3台服务器提供服务, 将根据性能分配虚拟节点
     */
    public static String[] servers = {
            "192.168.0.1#100", //服务器1: 性能指数100, 将获得1000个虚拟节点
            "192.168.0.2#100", //服务器2: 性能指数100, 将获得1000个虚拟节点
            "192.168.0.3#30"   //服务器3: 性能指数30,  将获得300个虚拟节点
    };
    /**
     * 真实服务器列表, 由于增加与删除的频率比遍历高, 用链表存储比较划算
     */
    private static List<String> realNodes = new LinkedList<>();
    /**
     * 虚拟节点列表
     */
    private static TreeMap<Integer, String> virtualNodes = new TreeMap<>();

    static{
        for(String s : servers){
            //把服务器加入真实服务器列表中
            realNodes.add(s);
            String[] strs = s.split("#");
            //服务器名称, 省略端口号
            String name = strs[0];
            //根据服务器性能给每台真实服务器分配虚拟节点, 并把虚拟节点放到虚拟节点列表中.
            int virtualNodeNum = Integer.parseInt(strs[1]) * 10;
            for(int i = 1; i <= virtualNodeNum; i++){
                virtualNodes.put(FVNHash(name + "@" + i), name + "@" + i);
            }
        }
    }

    public static void main(String[] args) {
        new Thread(new RequestProcess()).start();
    }

    static class RequestProcess implements Runnable{
        @Override
        public void run() {
            String client = null;
            while(true){
                //模拟产生一个请求
                client = getN() + "." + getN() + "." + getN() + "." + getN() + ":" + (1000 + (int)(Math.random() * 9000));
                //计算请求的哈希值
                int hash = FVNHash(client);
                //判断请求将由哪台服务器处理
                System.out.println(client + " 的请求将由 " + getServer(client) + " 处理");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    }

    private static String getServer(String client) {
        //计算客户端请求的哈希值
        int hash = FVNHash(client);
        //得到大于该哈希值的所有map集合
        SortedMap<Integer, String> subMap = virtualNodes.tailMap(hash);
        //找到比该值大的第一个虚拟节点, 如果没有比它大的虚拟节点, 根据哈希环, 则返回第一个节点.
        Integer targetKey = subMap.size() == 0 ? virtualNodes.firstKey() : subMap.firstKey();
        //通过该虚拟节点获得真实节点的名称
        String virtualNodeName = virtualNodes.get(targetKey);
        String realNodeName = virtualNodeName.split("@")[0];
        return realNodeName;
    }

    public static int getN(){
        return (int)(Math.random() * 128);
    }

    public static int FVNHash(String data){
        final int p = 16777619;
        int hash = (int)2166136261L;
        for(int i = 0; i < data.length(); i++)
            hash = (hash ^ data.charAt(i)) * p;
        hash += hash << 13;
        hash ^= hash >> 7;
        hash += hash << 3;
        hash ^= hash >> 17;
        hash += hash << 5;
        return hash < 0 ? Math.abs(hash) : hash;
    }
}

/* 运行结果片段
55.1.13.47:6240     的请求将由 192.168.0.1 处理
5.49.56.126:1105    的请求将由 192.168.0.1 处理
90.41.8.88:6884     的请求将由 192.168.0.2 处理
26.107.104.81:2989  的请求将由 192.168.0.2 处理
114.66.6.56:8233    的请求将由 192.168.0.1 处理
123.74.52.94:5523   的请求将由 192.168.0.1 处理
104.59.60.2:7502    的请求将由 192.168.0.2 处理
4.94.30.79:1299     的请求将由 192.168.0.1 处理
10.44.37.73:9332    的请求将由 192.168.0.2 处理
115.93.93.82:6333   的请求将由 192.168.0.2 处理
15.24.97.66:9177    的请求将由 192.168.0.2 处理
100.39.98.10:1023   的请求将由 192.168.0.2 处理
61.118.87.26:5108   的请求将由 192.168.0.2 处理
17.79.104.35:3901   的请求将由 192.168.0.1 处理
95.36.5.25:8020     的请求将由 192.168.0.2 处理
126.74.56.71:7792   的请求将由 192.168.0.2 处理
14.63.56.45:8275    的请求将由 192.168.0.1 处理
58.53.44.71:2089    的请求将由 192.168.0.3 处理
80.64.57.43:6144    的请求将由 192.168.0.2 处理
46.65.4.18:7649     的请求将由 192.168.0.2 处理
57.35.27.62:9607    的请求将由 192.168.0.2 处理
81.114.72.3:3444    的请求将由 192.168.0.1 处理
38.18.61.26:6295    的请求将由 192.168.0.2 处理
71.75.18.82:9686    的请求将由 192.168.0.2 处理
26.11.98.111:3781   的请求将由 192.168.0.1 处理
62.86.23.37:8570    的请求将由 192.168.0.3 处理
*/

public interface Constant {
    //zookeeper集群的地址
    String ZK_HOST = "192.168.117.129:2181,192.168.117.129:2182,192.168.117.129:2183";
    //连接zookeeper的超时时间
    int ZK_TIME_OUT = 5000;
    //服务器所发布的远程服务在zookeeper中的注册地址, 也就是说这个节点中保存了各个服务器提供的接口
    String ZK_REGISTRY = "/provider";
    //zookeeper集群中注册服务的url地址的瞬时节点
    String ZK_RMI = ZK_REGISTRY + "/rmi";
}

public class ServiceProvider {

    private CountDownLatch latch = new CountDownLatch(1);

    /**
     * 连接zookeeper集群
     */
    public ZooKeeper connectToZK(){
        ZooKeeper zk = null;
        try {
            zk = new ZooKeeper(Constant.ZK_HOST, Constant.ZK_TIME_OUT, new Watcher() {
                @Override
                public void process(WatchedEvent watchedEvent) {
                    //如果连接上了就唤醒当前线程.
                    latch.countDown();
                }
            });
            latch.await();//还没连接上时当前线程等待
        } catch (Exception e) {
            e.printStackTrace();
        }
        return zk;
    }

    /**
     * 创建znode节点
     * @param zk
     * @param url 节点中写入的数据
     */
    public void createNode(ZooKeeper zk, String url){
        try{
            //要把写入的数据转化为字节数组
            byte[] data = url.getBytes();
            zk.create(Constant.ZK_RMI, data, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 发布rmi服务
     */
    public String publishService(Remote remote, String host, int port){
        String url = null;
        try{
            LocateRegistry.createRegistry(port);
            url = "rmi://" + host + ":" + port + "/rmiService";
            Naming.bind(url, remote);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return url;
    }

    /**
     * 发布rmi服务, 并且将服务的url注册到zookeeper集群中
     */
    public void publish(Remote remote, String host, int port){
        //调用publishService, 得到服务的url地址
        String url = publishService(remote, host, port);
        if(null != url){
            ZooKeeper zk = connectToZK();//连接到zookeeper
            if(null != zk){
                createNode(zk, url);
            }
        }
    }
}

//UserService
public interface UserService extends Remote {
    public String helloRmi(String name) throws RemoteException;
}
//UserServiceImpl
public class UserServiceImpl implements UserService {

    public UserServiceImpl() throws RemoteException{
        super();
    }

    @Override
    public String helloRmi(String name) throws RemoteException {
        return "Hello " + name + "!";
    }
}

public static void main(String[] args) throws RemoteException {
    //创建 工具 类对象
    ServiceProvider sp = new ServiceProvider();
    //创建远程服务对象
    UserService userService = new UserServiceImpl();
    //完成发布
    sp.publish(userService, "localhost", 9999);
}

public static void main(String[] args){
    ServiceConsumer sc = new ServiceConsumer();//创建工具类对象
    while(true){
        //获得rmi远程服务对象
        UserService userService = sc.lookUp();
        try{
            //调用远程方法
            String result = userService.helloRmi("炭烧生蚝");
            System.out.println(result);
            Thread.sleep(100);
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

public class DataStatistics {
    private static float ReqToPort7777 = 0;
    private static float ReqToPort8888 = 0;
    private static float ReqToPort9999 = 0;

    public static void main(String[] args) {
        BufferedReader br = null;
        try {
            br = new BufferedReader(new FileReader("C://test.txt"));
            String line = null;
            while(null != (line = br.readLine())){
                if(line.contains("7777")){
                    ReqToPort7777++;
                }else if(line.contains("8888")){
                    ReqToPort8888++;
                }else if(line.contains("9999")){
                    ReqToPort9999++;
                }else{
                    print(false);
                }
            }
            print(true);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(null != br){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                br = null;
            }
        }
    }

    private static void print(boolean isEnd){
        if(!isEnd){
            System.out.println("------------- 服务器集群发生变化 -------------");
        }else{
            System.out.println("------------- 最后一次统计 -------------");
        }
        System.out.println("截取自上次服务器变化到现在: ");
        float total = ReqToPort7777 + ReqToPort8888 + ReqToPort9999;
        System.out.println("7777端口服务器访问量为: " + ReqToPort7777 + ", 占比" + (ReqToPort7777 / total));
        System.out.println("8888端口服务器访问量为: " + ReqToPort8888 + ", 占比" + (ReqToPort8888 / total));
        System.out.println("9999端口服务器访问量为: " + ReqToPort9999 + ", 占比" + (ReqToPort9999 / total));
        ReqToPort7777 = 0;
        ReqToPort8888 = 0;
        ReqToPort9999 = 0;
    }
}

/* 以下是输出结果
------------- 服务器集群发生变化 -------------
截取自上次服务器变化到现在: 
7777端口服务器访问量为: 198.0, 占比0.4419643
8888端口服务器访问量为: 184.0, 占比0.4107143
9999端口服务器访问量为: 66.0, 占比0.14732143
------------- 服务器集群发生变化 -------------
截取自上次服务器变化到现在: 
7777端口服务器访问量为: 510.0, 占比0.7589286
8888端口服务器访问量为: 1.0, 占比0.0014880953
9999端口服务器访问量为: 161.0, 占比0.23958333
------------- 最后一次统计 -------------
截取自上次服务器变化到现在: 
7777端口服务器访问量为: 410.0, 占比0.43248945
8888端口服务器访问量为: 398.0, 占比0.41983122
9999端口服务器访问量为: 140.0, 占比0.14767933
*/