/**
 * 普通輪詢算法
 */public class RoundRobin {
    private static Integer index = 0;
    private static List<String> nodes = new ArrayList<>();
    // 準備模擬數(shù)據(jù)
    static {
        nodes.add("192.168.1.101");
        nodes.add("192.168.1.103");
        nodes.add("192.168.1.102");
        System.out.println("普通輪詢算法的所有節(jié)點："+nodes);//打印所有節(jié)點
    }
    
    // 關鍵代碼
    public String selectNode(){
        String ip = null;
        synchronized (index){
            // 下標復位
            if(index>=nodes.size()) index = 0;
            ip = nodes.get(index);
            index++;
        }
        return ip;
    }

    // 并發(fā)測試：兩個線程循環(huán)獲取節(jié)點
    public static void main(String[] args) {
        new Thread(() -> {
            RoundRobin roundRobin1 = new RoundRobin();
            for (int i=1;i<=5;i++){
                String serverIp = roundRobin1.selectNode();
                System.out.println(Thread.currentThread().getName()+"==第"+i+"次獲取節(jié)點："+serverIp);
            }
        }).start();

        RoundRobin roundRobin2 = new RoundRobin();
        for (int i=1;i<=nodes.size();i++){
            String serverIp = roundRobin2.selectNode();
            System.out.println(Thread.currentThread().getName()+"==第"+i+"次獲取節(jié)點："+serverIp);
        }
    }
}

/**
 *  簡單版的加權輪詢
 */public class WeightedRoundRobinSimple {
    private static Integer index = 0;
    private static Map<String,Integer> mapNodes = new HashMap<>();

    // 準備模擬數(shù)據(jù)
    static {
        mapNodes.put("192.168.1.101",1);
        mapNodes.put("192.168.1.102",3);
        mapNodes.put("192.168.1.103",2);
        /* -- 以下代碼只為了方便查看所有節(jié)點，刪除不影響 -- S */
        List<String> nodes = new ArrayList<>();
        Iterator<Map.Entry<String, Integer>> iterator = mapNodes.entrySet().iterator();
        while (iterator.hasNext()){
            Map.Entry<String, Integer> entry = iterator.next();
            String key = entry.getKey();
            for (int i=0;i<entry.getValue();i++){
                nodes.add(key);
            }
        }
        System.out.println("簡單版的加權輪詢："+nodes);//打印所有節(jié)點
        /* -- 以上代碼只為了方便查看所有節(jié)點，刪除不影響-- E */
    }

    // 關鍵代碼：類似于二維數(shù)組 降維成 一維數(shù)組，然后使用普通輪詢
    public String selectNode(){
        List<String> nodes = new ArrayList<>();
        Iterator<Map.Entry<String, Integer>> iterator = mapNodes.entrySet().iterator();
        while (iterator.hasNext()){
            Map.Entry<String, Integer> entry = iterator.next();
            String key = entry.getKey();
            for (int i=0;i<entry.getValue();i++){
                nodes.add(key);
            }
        }
        String ip = null;
        synchronized (index){
            // 下標復位
            if(index>=nodes.size()) index = 0;
            ip = nodes.get(index);
            index++;
        }
        return ip;
    }

    // 并發(fā)測試：兩個線程循環(huán)獲取節(jié)點
    public static void main(String[] args) {
        new Thread(() -> {
            WeightedRoundRobinSimple roundRobin1 = new WeightedRoundRobinSimple();
            for (int i=1;i<=6;i++){
                String serverIp = roundRobin1.selectNode();
                System.out.println(Thread.currentThread().getName()+"==第"+i+"次獲取節(jié)點："+serverIp);
            }
        }).start();

        WeightedRoundRobinSimple roundRobin2 = new WeightedRoundRobinSimple();
        for (int i=1;i<=6;i++){
            String serverIp = roundRobin2.selectNode();
            System.out.println(Thread.currentThread().getName()+"==第"+i+"次獲取節(jié)點："+serverIp);
        }
    }
}

/**
 * String ip：負載IP
 * final Integer weight：權重，保存配置的權重
 * Integer effectiveWeight：有效權重，輪詢的過程權重可能變化
 * Integer currentWeight：當前權重，比對該值大小獲取節(jié)點
 *   第一次加權輪詢時：currentWeight = weight = effectiveWeight
 *   后面每次加權輪詢時：currentWeight 的值都會不斷變化，其他權重不變
 */public class Node implements Comparable<Node>{
    private String ip;
    private final Integer weight;
    private Integer effectiveWeight;
    private Integer currentWeight;

    public Node(String ip,Integer weight){
        this.ip = ip;
        this.weight = weight;
        this.effectiveWeight = weight;
        this.currentWeight = weight;
    }

    public Node(String ip, Integer weight, Integer effectiveWeight, Integer currentWeight) {
        this.ip = ip;
        this.weight = weight;
        this.effectiveWeight = effectiveWeight;
        this.currentWeight = currentWeight;
    }

    public String getIp() {
        return ip;
    }

    public void setIp(String ip) {
        this.ip = ip;
    }

    public Integer getWeight() {
        return weight;
    }

    public Integer getEffectiveWeight() {
        return effectiveWeight;
    }

    public void setEffectiveWeight(Integer effectiveWeight) {
        this.effectiveWeight = effectiveWeight;
    }

    public Integer getCurrentWeight() {
        return currentWeight;
    }

    public void setCurrentWeight(Integer currentWeight) {
        this.currentWeight = currentWeight;
    }

    @Override
    public int compareTo(Node node) {
        return currentWeight > node.currentWeight ? 1 : (currentWeight.equals(node.currentWeight) ? 0 : -1);
    }

    @Override
    public String toString() {
        return "{ip='" + ip + "', weight=" + weight + ", effectiveWeight=" + effectiveWeight + ", currentWeight=" + currentWeight + "}";
    }
}

/**
 * 加權輪詢算法
 */public class WeightedRoundRobin {

    private static List<Node> nodes = new ArrayList<>();
    // 權重之和
    private static Integer totalWeight = 0;
    // 準備模擬數(shù)據(jù)
    static {
        nodes.add(new Node("192.168.1.101",1));
        nodes.add(new Node("192.168.1.102",3));
        nodes.add(new Node("192.168.1.103",2));
        nodes.forEach(node -> totalWeight += node.getEffectiveWeight());
    }

    /**
     * 按照當前權重（currentWeight）最大值獲取IP
     * @return Node
     */
    public Node selectNode(){
        if (nodes ==null || nodes.size()<=0) return null;
        if (nodes.size() == 1)  return nodes.get(0);

        Node nodeOfMaxWeight = null; // 保存輪詢選中的節(jié)點信息
        synchronized (nodes){
            // 打印信息對象：避免并發(fā)時打印出來的信息太亂，不利于觀看結果
            StringBuffer sb = new StringBuffer();
            sb.append(Thread.currentThread().getName()+"==加權輪詢--[當前權重]值的變化："+printCurrentWeight(nodes));

            // 選出當前權重最大的節(jié)點
            Node tempNodeOfMaxWeight = null;
            for (Node node : nodes) {
                if (tempNodeOfMaxWeight == null)
                    tempNodeOfMaxWeight = node;
                else
                    tempNodeOfMaxWeight = tempNodeOfMaxWeight.compareTo(node) > 0 ? tempNodeOfMaxWeight : node;
            }
            // 必須new個新的節(jié)點實例來保存信息，否則引用指向同一個堆實例，后面的set操作將會修改節(jié)點信息
            nodeOfMaxWeight = new Node(tempNodeOfMaxWeight.getIp(),tempNodeOfMaxWeight.getWeight(),tempNodeOfMaxWeight.getEffectiveWeight(),tempNodeOfMaxWeight.getCurrentWeight());

            // 調(diào)整當前權重比：按權重（effectiveWeight）的比例進行調(diào)整，確保請求分發(fā)合理。
            tempNodeOfMaxWeight.setCurrentWeight(tempNodeOfMaxWeight.getCurrentWeight() - totalWeight);
            sb.append(" -> "+printCurrentWeight(nodes));

            nodes.forEach(node -> node.setCurrentWeight(node.getCurrentWeight()+node.getEffectiveWeight()));

            sb.append(" -> "+printCurrentWeight(nodes));
            System.out.println(sb); //打印權重變化過程
        }
        return nodeOfMaxWeight;
    }

    // 格式化打印信息
    private String printCurrentWeight(List<Node> nodes){
        StringBuffer stringBuffer = new StringBuffer("[");
        nodes.forEach(node -> stringBuffer.append(node.getCurrentWeight()+",") );
        return stringBuffer.substring(0, stringBuffer.length() - 1) + "]";
    }

    // 并發(fā)測試：兩個線程循環(huán)獲取節(jié)點
    public static void main(String[] args){
        Thread thread = new Thread(() -> {
            WeightedRoundRobin weightedRoundRobin1 = new WeightedRoundRobin();
            for(int i=1;i<=totalWeight;i++){
                Node node = weightedRoundRobin1.selectNode();
                System.out.println(Thread.currentThread().getName()+"==第"+i+"次輪詢選中[當前權重最大]的節(jié)點：" + node + "\n");
            }
        });
        thread.start();
        //
        WeightedRoundRobin weightedRoundRobin2 = new WeightedRoundRobin();
        for(int i=1;i<=totalWeight;i++){
            Node node = weightedRoundRobin2.selectNode();
            System.out.println(Thread.currentThread().getName()+"==第"+i+"次輪詢選中[當前權重最大]的節(jié)點：" + node + "\n");
        }

    }
}