윤문하다

주요 사상은 서버가 하나하나 서비스하는 것이다

1 단순화

public class RoundRobin {
    private static Integer pos = 0;

    public static String getServer() {
        if(pos >= ServerIps.LIST.size()) {
            pos = 0;
        }

        String ip = ServerIps.LIST.get(pos);
        pos++;
        return ip;
    }

    public static void main(String[] args) {
        for(int i = 0; i < 20; i++) {
            System.out.println(getServer());
        }
    }

}

2 최적화: 중요도 고려

권중을 고려할 때

폭력 해결, = LIST를 만들고 IP 주소를 권한의 크기에 따라 LIST에 넣습니다

역시 무작위 최적화 사상에 따른다

그 중에서 A, B, C는 각각 3개의 IP 주소를 대표하고, 권한은 각각 5, 3, 2 A:5 B:3 C:2이다.
좌표축에 매핑 0----5---8-10
offset의 수치는 더 이상 무작위 수가 아니라 0, 1, 2, 3, 4, 5, 6, 7, 8, 9이다
1 ——> A2 ——> A ...6 ——> B...
코드 구현

import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;


public class ServerIps {

    public static final Map WEIGHT_MAP = new LinkedHashMap<>();
    static {
        WEIGHT_MAP.put("192.168.0.1", 2);
        WEIGHT_MAP.put("192.168.0.2", 8);
        WEIGHT_MAP.put("192.168.0.3", 1);
        WEIGHT_MAP.put("192.168.0.4", 9);
        WEIGHT_MAP.put("192.168.0.5", 4);
        WEIGHT_MAP.put("192.168.0.6", 6);
    }

}

출력 순서와 입력 순서가 일치하도록 LinkedHashMap을 사용합니다.

public class RequestId {
    public static Integer num = 0;

    public static Integer getAndIncrement() {
        return num++;
    }

}

위의 코드는 고객의 ID 번호를 모방하여 고객의 ID 번호에 따라 서버의 폴링을 제어합니다.

public class RoundRobin2 {
public static String getServer() {

        int totalWeight = 0;
        for (Integer weight: ServerIps.WEIGHT_MAP.values()) {
            totalWeight += weight;
        }

        int requestId = RequestId.getAndIncrement();
        int offset = requestId % totalWeight;

        for(String ip: ServerIps.WEIGHT_MAP.keySet()) {
            Integer weight = ServerIps.WEIGHT_MAP.get(ip);
            if (offset < weight) {
                return ip;
            }

            offset -= weight;
        }
        return null;

    }

    public static void main(String[] args) {

        for (int i = 0; i < 10; i++) {
            System.out.println(getServer());
        }
    }

}

3 최적화: 매끄러운 가중 퀴즈 알고리즘

Nginx는 기본적으로 이러한 알고리즘을 사용합니다.
A:5B:1C:1 이렇게 하면 최적화 1의 접근 순서가 AAABC이고 이렇게 하면 서버 A에 대한 압력이 비교적 크다
만약 이산에 따른다면 이런 문제는 없을 것이다. 예를 들어 아래와 같은 순서인 AABACAA는 서비스를 비교적 분산시킬 수 있을 뿐만 아니라 권중도 보장할 수 있을 뿐만 아니라 윤문의 목적도 달성할 수 있다
구체적인 절차는 다음과 같다.
ipweight: 정적, 5,1,1currentWeight: 동적
currentWeight: 0,0,0
 
currentWeight+=weight
max(currentWeight)
result
max(currentWeight)-=sum(weight)7
5,1,1
오
A
-2,1,1
3,2,2
삼
A
-4,2,2
1,3,3
삼
B
1,-4,3
6,-3,4
육
A
-1,-3,4
4,-2,5
오
C
4,-2,-2
9,-1,-1
구
A
2,-1,-1
7,0,0
칠
A
0,0,0
5,1,1
...
...
...
 
코드 구현

public class Weight {
    private String ip;
    private Integer weight;
    private Integer currentWeight;

    public Weight(String ip, Integer weight, Integer currentWeight) {
        super();
        this.ip = ip;
        this.weight = weight;
        this.currentWeight = currentWeight;
    }

    public String getIp() {
        return ip;
    }

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

    public Integer getWeight() {
        return weight;
    }

    public void setWeight(Integer weight) {
        this.weight = weight;
    }

    public Integer getCurrentWeight() {
        return currentWeight;
    }

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

}

=============================

import java.util.LinkedHashMap;
import java.util.Map;

public class WeightRoundRobin {
    private static Map weightMap = new LinkedHashMap<>();

    public static String getServer() {
        if(weightMap.isEmpty()) {
            for(String ip: ServerIps.WEIGHT_MAP.keySet()) {
                Integer weight = ServerIps.WEIGHT_MAP.get(ip);          
                weightMap.put(ip, new Weight(ip, weight, 0));

            }
        }
        // currentWeight += weight
        for(Weight weight: weightMap.values()) {
            weight.setCurrentWeight(weight.getCurrentWeight() + weight.getWeight());
        }

        Weight maxCurrentWeight = null;
        for (Weight weight: weightMap.values()) {
            if (maxCurrentWeight == null || weight.getCurrentWeight() > maxCurrentWeight.getCurrentWeight()) {
                maxCurrentWeight = weight;
            }
        }

        // max(currentWeight) -= sum(weight)
        int totalWeight = 0;
        for (Integer weight: ServerIps.WEIGHT_MAP.values()) {
            totalWeight += weight;
        }

        maxCurrentWeight.setCurrentWeight(maxCurrentWeight.getCurrentWeight() - totalWeight);

        //result
        return maxCurrentWeight.getIp();
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println(getServer());
        }
    }
}