Einfacher Abfragealgorithmus
Dieser Algorithmus ist relativ einfach. Sie haben beispielsweise drei Server
| 192.168.1.3 | |
| 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. |
Der erste Server
1
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());
}
}
}Nach dem Login kopieren | Das laufende Ergebnis zu diesem Zeitpunkt ist ||
| Anfrage | ||
| Gesamtgewicht | aktuelles Maximalgewicht | Zurückgegebenes IP |
{5,1,1}
7
{-2, 1,3 ,3}
73| {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 | |
| 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 ip | |
| 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: | 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;
}
}Nach dem Login kopieren | Es ist ersichtlich, dass das Ausführungsergebnis hier mit dem in beschriebenen Ergebnis übereinstimmt der Tisch. |
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!
