Wie Nginx den Abfragealgorithmus implementiert

Einfacher Abfragealgorithmus

Dieser Algorithmus ist relativ einfach. Sie haben beispielsweise drei Server

Der dritte Server192.168.1.3

public class simplepolling {

  /**
   * key是ip
   */
  public static list <string> ipservice = new linkedlist <>();
  static {
    ipservice.add("192.168.1.1");
    ipservice.add("192.168.1.2");
    ipservice.add("192.168.1.3");
  }
  public static int pos = 0;
  public static string getip(){
    if(pos >= ipservice.size()){
      //防止索引越界
      pos = 0;
    }
    string ip = ipservice.get(pos);
    pos ++;
    return ip;

  }

  public static void main(string[] args) {
    for (int i = 0; i < 4; i++) {
      system.out.println(getip());

    }
  }
}

Gewichteter Abfragealgorithmus

Nachdem die erste Anfrage eingegangen ist, wird standardmäßig auf den ersten Server zugegriffen, die zweite Anfrage wird auf den zweiten Server zugreifen und die dritte Anfrage wird auf den dritten Server zugreifen . Die vierte Aufforderung kommt, die erste Station zu besuchen, und so weiter. Das Folgende ist ein einfacher Algorithmus, der von meinem Code implementiert wird:	Das Ergebnis von 4 simulierten Ausführungen ist
	Wenn ich zu diesem Zeitpunkt einen Server mit besserer Leistung habe (z. B. 192.168.1.1), möchte ich dies Server verarbeitet mehr Eine kleine Anfrage, diesmal mit Wahrscheinlichkeitsgewichtung, kann dieser Algorithmus nicht implementiert werden. Bitte sehen Sie sich den Polling-Algorithmus der aktualisierten Version an, den ich später beschreibe.

Zu diesem Zeitpunkt muss ich die Gewichtungen der drei Server vor mir festlegen. Beispielsweise ist der erste Server auf 5, der zweite Server auf 1 und der dritte eingestellt Server ist auf 1 eingestellt.

Der erste Server

Dritter Server

192.168.1.3

1

Top 5 zu diesem Zeitpunkt Jede Anfrage greift auf den ersten Server zu, die sechste Anfrage greift auf den zweiten Server zu und die siebte Anfrage greift auf den dritten Server zu. Das Folgende ist das Codebeispiel, das ich gegeben habe: Das laufende Ergebnis zu diesem Zeitpunkt ist Der erste sichtbare Server wurde 5 Mal ausgeführt, die nächsten 2 Server wurden einmal ausgeführt und bald. Vielleicht denken Sie, dass dieser Algorithmus nicht schlecht ist. Tatsächlich besteht ein Nachteil dieses Algorithmus darin, dass ich möglicherweise viele Anforderungen an den ersten Server ausführen muss, wenn das Gewicht des ersten Servers zu groß ist. In diesem Fall ist die Verteilung ungleichmäßig und führt zu Druck auf einem bestimmten Server. Übermäßige Größe führt zum Zusammenbruch. Deshalb werde ich später einen dritten Algorithmus vorstellen, um dieses Problem zu lösen Kombiniert werde ich mein eigenes Verständnis mit Bildern und Text erläutern. Die Serverkonfiguration und das Gewicht, die ich hier als Beispiel gebe, sind immer noch die gleichen wie obenaktuelles Gewicht = Eigengewicht + aktuelles Gewicht nach AuswahlAktuelles Gewicht nach Auswahl = aktuelles Maximalgewicht - Gesamtgewicht

public class weightpolling { /** * key是ip,value是权重 */ public static map<string, integer> ipservice = new linkedhashmap<>(); static { ipservice.put("192.168.1.1", 5); ipservice.put("192.168.1.2", 1); ipservice.put("192.168.1.3", 1); } public static int requestid = 0; public static int getandincrement() { return requestid++; } public static string getip(){ //获取总的权重 int totalweight =0; for (integer value : ipservice.values()) { totalweight+= value; } //获取当前轮询的值 int andincrement = getandincrement(); int pos = andincrement% totalweight; for (string ip : ipservice.keyset()) { if(pos < ipservice.get(ip)){ return ip; } pos -= ipservice.get(ip); } return null; } public static void main(string[] args) { for (int i = 0; i < 7; i++) { system.out.println(getip()); } } }
		Anfrage
Gesamtgewicht	aktuelles Maximalgewicht	Zurückgegebenes IP

1

{5,1,1}

7

5

192 .168 .1.1

{-2, 1,3 ,3}

7

3192.168.1.2192,16 8.1.1 8.1.3{4,-2,-2}{2,-1,-1}{0,0,0}Wie Sie auf dem Bild oben sehen können, obwohl das Gewicht von Der erste Server ist auf 5 eingestellt, es ist nicht die fünfte Anfrage. Sie werden alle auf dem ersten Server ausgeführt, aber die Planungssequenz ist sehr einheitlich und das aktuelle Gewicht kehrt zu {0, 0, zurück. 0} nach der Auswahl in der siebten Planung Der Status der Instanz stimmt mit dem Anfangsstatus überein Der Planungsvorgang kann in Zukunft wiederholt werden. Einige Leute verstehen die Bedeutung des vorherigen Bildes möglicherweise nicht genau: 1 Das Gesamtgewicht wird sich nicht ändern 2 . In Kapitel 2. Wenn eine Anfrage eingeht, initialisiere ich den aktuellen Gewichtungswert standardmäßig auf {0,0,0}, sodass der aktuelle Gewichtungswert {5+0,1+0,1+0} ist, wobei 5,1,1 ist die von jedem Server festgelegte Gewichtung, die wir zuvor festgelegt haben. 3. Hier können wir daraus schließen, dass das maximale Gewicht der ersten Anfrage 5 beträgt. Dann kehren wir zum ersten Server zurück ip4. Dann wird das aktuelle Maximalgewicht abzüglich des Gesamtgewichts (5-7) festgelegt Der Wert des ausgewählten Gewichts beträgt {5-7,1,1}5. Wenn die zweite Anfrage eingeht, fahren wir mit den Schritten 2, 3 und 4 fort Wenn ich es hier nicht verstehe, werde ich unten meinen eigenen Java-Code bereitstellen. Implementierter Algorithmus: Das Ausführungsergebnis des Codes hier ist: Es ist ersichtlich, dass das Ausführungsergebnis hier mit dem in beschriebenen Ergebnis übereinstimmt der Tisch.

{1,-4,3}		4	{6,-3,4}	7	6
	6	{9,-1,-1}	7	9	192.168.1.1
	7	{7,0,0}	7	7	192.168.1.1
	public class polling { /** * key是ip,value是权重 */ public static map <string,integer> ipservice = new linkedhashmap <>(); static { ipservice.put("192.168.1.1",5); ipservice.put("192.168.1.2",1); ipservice.put("192.168.1.3",1); } private static map<string,weight> weightmap = new linkedhashmap <>(); public static string getip(){ //计算总的权重 int totalweight = 0; for (integer value : ipservice.values()) { totalweight+=value; } //首先判断weightmap是否为空 if(weightmap.isempty()){ ipservice.foreach((ip,weight)->{ weight weights = new weight(ip, weight,0); weightmap.put(ip,weights); }); } //给map中得对象设置当前权重 weightmap.foreach((ip,weight)->{ weight.setcurrentweight(weight.getweight() + weight.getcurrentweight()); }); //判断最大权重是否大于当前权重,如果为空或者小于当前权重，则把当前权重赋值给最大权重 weight maxweight = null; for (weight weight : weightmap.values()) { if(maxweight ==null || weight.getcurrentweight() > maxweight.getcurrentweight()){ maxweight = weight; } } //最后把当前最大权重减去总的权重 maxweight.setcurrentweight(maxweight.getcurrentweight() - totalweight); //返回 return maxweight.getip(); } public static void main(string[] args) { //模拟轮询7次取ip for (int i = 0; i < 7; i++) { system.out.println(getip()); } } } class weight{ /** * ip */ private string ip; /** * 设置得权重 */ private int weight; /** * 当前权重 */ private int currentweight; public weight(string ip, int weight,int currentweight) { this.ip = ip; this.weight = weight; this.currentweight = currentweight; } public string getip() { return ip; } public void setip(string ip) { this.ip = ip; } public int getweight() { return weight; } public void setweight(int weight) { this.weight = weight; } public int getcurrentweight() { return currentweight; } public void setcurrentweight(int currentweight) { this.currentweight = currentweight; } }

Das obige ist der detaillierte Inhalt vonWie Nginx den Abfragealgorithmus implementiert. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!