技术选型一第五周作业「架构师训练营第 1 期」

package com.loadbalance;
import java.util.ArrayList;
import java.util.List;
import java.util.SortedMap;
import java.util.TreeMap;
public class OneHashV {
    private List<String> serverList = new ArrayList<String>(2000);
    private SortedMap<Integer,String> serverHashCycle = new TreeMap<Integer, String>();
    private int vnodeLength =150;// 虚拟节点数量
    public OneHashV(int nodeNum){
        this.vnodeLength = nodeNum;
    }
    public void addServer(String server){
        serverList.add(server);
    }
    public List<String> getServerList(){
        return this.serverList;
    }
    public void initHashCycle(){
        for (String server : serverList) {
            for (int i = 0; i < vnodeLength; i++) {
                String value = i+"|"+server;
                int serverHashCode = getHash(value);
//                System.out.println(serverHashCode);
                serverHashCycle.put(serverHashCode,value);// 每个服务器节点，都有150个虚拟节点
            }
        }
    }
    public int getHash(String input){
        // java默认的hashCode不够均匀，相似的字符串为连续的数据 1874591590 1874591591 1874591592等
        int hash =  input.hashCode();
        if (hash < 0)
            hash = Math.abs(hash);
        hash = (int) (hash % (Math.pow(2,32)));//Math.pow(2,32)  4.294967296E9
        return hash;
    }
    public String getServer(String key){
        int keyHashcode = getHash(key);
//        System.out.println("获取的："+keyHashcode);
        SortedMap<Integer, String> moreThanKeyHash = serverHashCycle.tailMap(keyHashcode);
        if(moreThanKeyHash.isEmpty()){
            // 没有大于key hashcode的节点，则取map第一个节点
            Integer nodeIndex = serverHashCycle.firstKey();
            return mapServer(serverHashCycle.get(nodeIndex));
        }else{
            // 大于key hashCode
            Integer nodeIndex = moreThanKeyHash.firstKey();
            return mapServer(moreThanKeyHash.get(nodeIndex));
        }
    }
    // map的value值，是否要处理
    public String mapServer(String serverValue){
        if(serverValue != null){
            String[] split = serverValue.split("\\|");
            return split[1];
        }
        return null;
    }   
}

public class OneHashVTest {
    public static void test(int num){
        OneHashV oneHash = new OneHashV(num);
        oneHash.addServer("192.168.2.1:4444");
        oneHash.addServer("192.168.3.1:4445");
        oneHash.addServer("192.168.4.1:4446");
        oneHash.addServer("192.168.5.1:4447");
        oneHash.addServer("192.168.6.1:4448");
        oneHash.addServer("192.168.7.1:4449");
        oneHash.addServer("192.168.8.1:4450");
        oneHash.addServer("192.168.9.1:4451");
        oneHash.addServer("192.168.10.1:4452");
        oneHash.addServer("192.168.11.1:4453");
        oneHash.initHashCycle();
        Map<String,Map<String,String>> serverData = new HashMap<String,Map<String,String>>();
        // 初始化
        List<String> serverList = oneHash.getServerList();
        for (String server : serverList) {
            Map<String,String> data = new HashMap<String,String>();
            serverData.put(server,data);
        }
        int saveTotal = 1000000;
        int serverNum = serverList.size();
        int average = saveTotal/serverNum;
        System.out.println("存储数据:"+saveTotal+" 服务器数量："+serverNum+" 虚拟节点："+num);
        for (int i = 0; i < saveTotal; i++) {
            String key = i + "key"+i;
            String value = i+"value"+i;
            String server = oneHash.getServer(key);
            Map<String, String> dataMap = serverData.get(server);
            dataMap.put(key,value);
        }
        // 比较每个服务器节点存储的数据的方差
        long ftaol = 0;
        Iterator<Map.Entry<String, Map<String, String>>> iterator = serverData.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Map<String, String>> next = iterator.next();
            String key = next.getKey();
            Map<String, String> value = next.getValue();
            int size = value.size();
            ftaol += ((size-average)*(size-average));
            System.out.println("服务器："+key+" 数量："+size+" 临时汇总："+ftaol);
        }
        System.out.println("方差："+ftaol);
        double stand = Math.sqrt(ftaol);
        System.out.println("标准差："+stand);
        System.out.println("================================");
    }
    public static void main(String[] args) {
        test(150);
        test(100);
        test(50);
    }
}