Detaillierte Erläuterung der zugrunde liegenden Implementierungsmethode des Nginx-Polling-Algorithmus

Nachdem die erste Anfrage eingegangen ist, wird standardmäßig auf den ersten Server zugegriffen. Die zweite Anfrage geht ein, um auf den zweiten Server zuzugreifen. Die dritte Anfrage geht ein, um auf den dritten Server zuzugreifen. Die vierte Anfrage geht ein, um auf den ersten Server zuzugreifen, und so weiter. Das Folgende ist mein Code zur Implementierung eines einfachen Algorithmus:

öffentliche Klasse SimplePolling {

  /**
   * Schlüssel ist IP
   */
  öffentliche statische Liste <String> ipService = neue LinkedList <>();
  statisch {
    ipService.add("192.168.1.1");
    ipService.add("192.168.1.2");
    ipService.add("192.168.1.3");
  }
  öffentliche statische int pos = 0;
  öffentliche statische Zeichenfolge getIp(){
    wenn(pos >= ipService.size()){
      //Verhindern, dass der Index den Rahmen überschreitet pos = 0;
    }
    Zeichenfolge ip = ipService.get(pos);
    Position++;
    IP zurückgeben;

  }

  öffentliche statische void main(String[] args) {
    für (int i = 0; i < 4; i++) {
      System.out.println(getIp());

    }
  }
}

Die Simulation wurde viermal durchgeführt und die Ergebnisse waren

Wenn ich zu diesem Zeitpunkt einen Server mit besserer Leistung habe (z. B. 192.168.1.1), möchte ich, dass dieser Server mehr Anfragen verarbeitet. Zu diesem Zeitpunkt ist die Wahrscheinlichkeit von Gewichten beteiligt und dieser Algorithmus kann nicht implementiert werden. Bitte beachten Sie die aktualisierte Version des Polling-Algorithmus, die ich später beschreiben werde.

Gewichtetes Round Robin

Jetzt muss ich die Gewichte meiner ersten drei Server festlegen, z. B. 5 für den ersten Server, 1 für den zweiten Server und 1 für den dritten Server.

Zu diesem Zeitpunkt greifen die ersten fünf Anfragen auf den ersten Server zu, die sechste Anfrage auf den zweiten Server und die siebte Anfrage auf den dritten Server.

Hier ist das Codebeispiel, das ich angegeben habe:

öffentliche Klasse WeightPolling {

  /**
   * Schlüssel ist IP, Wert ist Gewicht*/
  öffentliche statische Map<String, Integer> ipService = neue LinkedHashMap<>();
  statisch {
    ipService.put("192.168.1.1", 5);
    ipService.put("192.168.1.2", 1);
    ipService.put("192.168.1.3", 1);
  }
  öffentliche statische int requestId = 0;
  öffentliche statische int getAndIncrement() {
    gib Anfrage-ID++ zurück;
  }

  öffentliche statische Zeichenfolge getIp(){
    //Das Gesamtgewicht abrufen int totalWeight =0;
    für (Integer-Wert: ipService.values()) {
      Gesamtgewicht+= Wert;
    }
    //Den aktuellen Polling-Wert abrufen int andIncrement = getAndIncrement();
    int pos = undInkrement% Gesamtgewicht;
    für (String ip : ipService.keySet()) {
      wenn(pos < ipService.get(ip)){
        IP zurückgeben;
      }
      pos -= ipService.get(ip);
    }
    gibt null zurück;
  }

  öffentliche statische void main(String[] args) {
    für (int i = 0; i < 7; i++) {
      System.out.println(getIp());
    }
  }

}

Das Ergebnis dieses Mals ist

Es ist ersichtlich, dass der erste Server fünfmal ausgeführt wurde, die nächsten beiden Server jeweils einmal und so weiter. Vielleicht denken Sie, dass dieser Algorithmus nicht schlecht ist. Tatsächlich hat dieser Algorithmus einen Nachteil. Wenn ich das Gewicht des ersten Servers zu hoch einstelle, muss ich möglicherweise viele Anfragen an den ersten Server ausführen. In diesem Fall ist die Verteilung ungleichmäßig, was zu übermäßigem Druck auf einem Server führen und ihn zum Absturz bringen kann. Daher werde ich später einen dritten Algorithmus zur Lösung dieses Problems vorstellen.

Glatter gewichteter Round-Robin-Algorithmus

Dieser Algorithmus kann kompliziert sein. Als ich ihn das erste Mal sah, verstand ich ihn nicht ganz. Nachdem ich die relevanten Informationen gelesen hatte, kombinierte ich mein eigenes Verständnis, um ihn Ihnen mit Bildern und Text zu erklären. Die Serverkonfiguration und die Gewichte, die ich hier als Beispiele verwendet habe, sind dieselben wie oben.

Aus der obigen Abbildung ist ersichtlich, dass, obwohl das Gewicht des ersten Servers auf 5 eingestellt ist, die fünfte Anforderung nicht immer vom ersten Server ausgeführt wird. Stattdessen wird die Ausführung verteilt und die Planungsreihenfolge ist sehr einheitlich. Darüber hinaus wird nach der siebten Planung das aktuelle Gewicht auf {0, 0, 0} zurückgesetzt und der Status der Instanz stimmt mit dem Anfangsstatus überein, sodass der Planungsvorgang anschließend wiederholt werden kann.

Manchen Leuten ist die Bedeutung des vorherigen Bildes vielleicht nicht ganz klar, deshalb gebe ich hier eine kurze Beschreibung:

1. Zunächst ändert sich das Gesamtgewicht nicht. Standardmäßig ist es die Summe der aktuell eingestellten Gewichte.

2. Wenn die erste Anfrage eingeht, initialisiere ich den aktuell ausgewählten Gewichtungswert standardmäßig auf {0,0,0}, sodass der aktuelle Gewichtungswert {5+0,1+0,1+0} ist, wobei 5,1,1 die Gewichtung ist, die wir zuvor für jeden Server festgelegt haben.

3. Hier können wir schlussfolgern, dass das maximale Gewicht der ersten Anfrage 5 beträgt. Kehren Sie dann zur ersten Server-IP zurück

4. Dann legen wir das aktuelle Gewicht nach der Auswahl fest, das das aktuelle Maximalgewicht abzüglich des Gesamtgewichts (5-7) ist. Das nicht ausgewählte Gewicht bleibt unverändert. Zu diesem Zeitpunkt beträgt der Wert des aktuell ausgewählten Gewichts {5-7,1,1}

5. Wenn die zweite Anfrage eintrifft, führen wir die oben genannten Schritte 2, 3 und 4 weiter aus.

Wenn Sie es immer noch nicht verstehen, stelle ich unten meinen eigenen, in Java-Code implementierten Algorithmus bereit:

öffentliche Klasse Polling {

  /**
   * Schlüssel ist IP, Wert ist Gewicht*/
  öffentliche statische Map<String,Integer> ipService = neue LinkedHashMap<>();
  statisch {
    ipService.put("192.168.1.1",5);
    ipService.put("192.168.1.2",1);
    ipService.put("192.168.1.3",1);
  }
  private statische Map<String,Gewicht> GewichtMap = neue LinkedHashMap <>();

  öffentliche statische Zeichenfolge getIp(){
    //Berechnen Sie das Gesamtgewicht int totalWeight = 0;
    für (Integer-Wert: ipService.values()) {
      Gesamtgewicht+=Wert;
    }
    //Zuerst feststellen, ob weightMap leer ist if (weightMap.isEmpty()) {
      ipService.forEach((ip,gewicht)->{
        Gewicht Gewichte = neues Gewicht (IP, Gewicht, 0);
        weightMap.put(ip, Gewichte);
      });
    }
    //Das aktuelle Gewicht für das Objekt in der Karte festlegen weightMap.forEach((ip,weight)->{
      Gewicht.aktuellesGewichtfestlegen(Gewicht.Gewicht abrufen() + Gewicht.aktuellesGewicht abrufen());
    });

    //Beurteilen Sie, ob das Maximalgewicht größer als das aktuelle Gewicht ist. Wenn es leer oder kleiner als das aktuelle Gewicht ist, weisen Sie dem Maximalgewicht das aktuelle Gewicht zu. Weight maxWeight = null;
    für (Gewicht Gewicht : weightMap.values()) {
      wenn(maxWeight == null || Gewicht.getCurrentWeight() > maxWeight.getCurrentWeight()){
        maxGewicht = Gewicht;
      }
    }
    //Zum Schluss das Gesamtgewicht vom aktuellen Maximalgewicht abziehen maxWeight.setCurrentWeight(maxWeight.getCurrentWeight() - totalWeight);
    //zurückgeben return maxWeight.getIp();
  }

  öffentliche statische void main(String[] args) {
    //Simulieren Sie 7-mal das Polling, um die IP zu erhalten
    für (int i = 0; i < 7; i++) {
      System.out.println(getIp());
    }
  }

}

Klasse Gewicht{
  /**
   * IP-Adresse
   */
  private String-IP;
  /**
   * Gewicht einstellen */
  privates int Gewicht;
  /**
   * Aktuelles Gewicht */
  private int aktuellesGewicht;

  öffentliches Gewicht(String ip, int Gewicht, int aktuelles Gewicht) {
    dies.ip = ip;
    dieses.Gewicht = Gewicht;
    this.currentWeight = aktuellesGewicht;
  }

  öffentlicher String getIp() {
    IP zurückgeben;
  }

  öffentliche void setIp(String ip) {
    dies.ip = ip;
  }

  öffentliche int getWeight() {
    Rücklaufgewicht;
  }

  öffentliche void setWeight(int Gewicht) {
    dieses.Gewicht = Gewicht;
  }

  öffentliche int getAktuellesGewicht() {
    Rückstromgewicht;
  }

  öffentliche void setzeAktuellesGewicht(int aktuellesGewicht) {
    this.currentWeight = aktuellesGewicht;
  }
}

Das Ergebnis der Ausführung des Codes ist hier:

Es ist ersichtlich, dass die Ausführungsergebnisse hier mit den in der Tabelle beschriebenen Ergebnissen übereinstimmen.

Zusammenfassen

Der dritte Algorithmus ist möglicherweise etwas kompliziert zu verstehen. Wenn Sie die Bedeutung des Diagramms nicht verstehen, können Sie zuerst den Code ausführen. Nach dem schrittweisen Debuggen mit dem Debugger ist es leicht zu verstehen.

Das Obige ist der vollständige Inhalt dieses Artikels. Ich hoffe, er wird für jedermanns Studium hilfreich sein. Ich hoffe auch, dass jeder 123WORDPRESS.COM unterstützen wird.