package com.yty.loadbalancingalgorithm.wrr;

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

    public ServerNode(String ip, Integer weight){
        this(ip,weight,true);
    }
    public ServerNode(String ip, Integer weight,Boolean isAvailable){
        this.ip = ip;
        this.weight = weight;
        this.effectiveWeight = weight;
        this.currentWeight = weight;
        this.isAvailable = isAvailable;
    }

    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;
    }

    public Boolean isAvailable() {
        return isAvailable;
    }
    public void setIsAvailable(Boolean isAvailable){
        this.isAvailable = isAvailable;
    }

    // 每成功一次，恢復有效權重1，不超過配置的起始權重
    public void onInvokeSuccess(){
        if(effectiveWeight < weight) effectiveWeight++;
    }
    // 每失敗一次，有效權重減少1，無底線的減少
    public void onInvokeFault(){
        effectiveWeight--;
    }

    @Override
    public int compareTo(ServerNode 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 + ", isAvailable=" + isAvailable + "}";
    }
}

package com.yty.loadbalancingalgorithm.wrr;

import java.util.ArrayList;
import java.util.List;

/**
 * 加權輪詢算法：加入存活狀態(tài)，降權使宕機權重降低，從而不會被選中
 */
public class WeightedRoundRobinAvailable {

    private static List<ServerNode> serverNodes = new ArrayList<>();
    // 準備模擬數(shù)據(jù)
    static {
        serverNodes.add(new ServerNode("192.168.1.101",1));// 默認為true
        serverNodes.add(new ServerNode("192.168.1.102",3,false));
        serverNodes.add(new ServerNode("192.168.1.103",2));
    }

    /**
     * 按照當前權重（currentWeight）最大值獲取IP
     * @return ServerNode
     */
    public ServerNode selectNode(){
        if (serverNodes.size() <= 0) return null;
        if (serverNodes.size() == 1)
            return (serverNodes.get(0).isAvailable()) ? serverNodes.get(0) : null;
        
        // 權重之和
        Integer totalWeight = 0;
        ServerNode nodeOfMaxWeight = null; // 保存輪詢選中的節(jié)點信息
        synchronized (serverNodes){
            StringBuffer sb1 = new StringBuffer();
            StringBuffer sb2 = new StringBuffer();
            sb1.append(Thread.currentThread().getName()+"==加權輪詢--[當前權重]值的變化："+printCurrentWeight(serverNodes));
            // 有限權重總和可能發(fā)生變化
            for(ServerNode serverNode : serverNodes){
                totalWeight += serverNode.getEffectiveWeight();
            }

            // 選出當前權重最大的節(jié)點
            ServerNode tempNodeOfMaxWeight = serverNodes.get(0);
            for (ServerNode serverNode : serverNodes) {
                if (serverNode.isAvailable()) {
                    serverNode.onInvokeSuccess();//提權
                    sb2.append(Thread.currentThread().getName()+"==[正常節(jié)點]："+serverNode+"\n");
                } else {
                    serverNode.onInvokeFault();//降權
                    sb2.append(Thread.currentThread().getName()+"==[宕機節(jié)點]："+serverNode+"\n");
                }

                tempNodeOfMaxWeight = tempNodeOfMaxWeight.compareTo(serverNode) > 0 ? tempNodeOfMaxWeight : serverNode;
            }
            // 必須new個新的節(jié)點實例來保存信息，否則引用指向同一個堆實例，后面的set操作將會修改節(jié)點信息
            nodeOfMaxWeight = new ServerNode(tempNodeOfMaxWeight.getIp(),tempNodeOfMaxWeight.getWeight(),tempNodeOfMaxWeight.isAvailable());
            nodeOfMaxWeight.setEffectiveWeight(tempNodeOfMaxWeight.getEffectiveWeight());
            nodeOfMaxWeight.setCurrentWeight(tempNodeOfMaxWeight.getCurrentWeight());

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

            serverNodes.forEach(serverNode -> serverNode.setCurrentWeight(serverNode.getCurrentWeight()+serverNode.getEffectiveWeight()));

            sb1.append(" -> "+printCurrentWeight(serverNodes));
            System.out.print(sb2);  //所有節(jié)點的當前信息
            System.out.println(sb1); //打印當前權重變化過程
        }
        return nodeOfMaxWeight;
    }

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

    // 并發(fā)測試：兩個線程循環(huán)獲取節(jié)點
    public static void main(String[] args) throws InterruptedException {
        // 循環(huán)次數(shù)
        int loop = 18;

        new Thread(() -> {
            WeightedRoundRobinAvailable weightedRoundRobin1 = new WeightedRoundRobinAvailable();
            for(int i=1;i<=loop;i++){
                ServerNode serverNode = weightedRoundRobin1.selectNode();
                System.out.println(Thread.currentThread().getName()+"==第"+i+"次輪詢選中[當前權重最大]的節(jié)點：" + serverNode + "\n");
            }
        }).start();
        //
        new Thread(() -> {
            WeightedRoundRobinAvailable weightedRoundRobin2 = new WeightedRoundRobinAvailable();
            for(int i=1;i<=loop;i++){
                ServerNode serverNode = weightedRoundRobin2.selectNode();
                System.out.println(Thread.currentThread().getName()+"==第"+i+"次輪詢選中[當前權重最大]的節(jié)點：" + serverNode + "\n");
            }
        }).start();

        //main 線程睡了一下，再偷偷把 所有宕機 拉起來：模擬服務器恢復正常
        Thread.sleep(5);
        for (ServerNode serverNode:serverNodes){
            if(!serverNode.isAvailable())
                serverNode.setIsAvailable(true);
        }
    }
}