Bagaimana Nginx melaksanakan algoritma pengundian

Algoritma pengundian mudah

Algoritma ini agak mudah Sebagai contoh, anda mempunyai tiga pelayan

第一台服务器	192.168.1.1
第二台服务器	192.168.1.2
第三台服务器	192.168.1.3

Permintaan pertama akan diakses secara lalai. permintaan datang untuk mengakses stesen kedua, permintaan ketiga datang untuk mengakses stesen ketiga, permintaan keempat datang untuk mengakses stesen pertama, dan seterusnya. Berikut ialah algoritma mudah yang dilaksanakan oleh kod saya:

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());

    }
  }
}

Hasil daripada 4 pelaksanaan simulasi ialah

Pada masa ini, jika saya mempunyai perbandingan prestasi pelayan OK (seperti 192.168.1.1), saya mahu pelayan ini mengendalikan lebih banyak permintaan Pada masa ini, kebarangkalian berat terlibat Algoritma ini tidak boleh dilaksanakan.

Algoritma pengundian berwajaran

Pada masa ini saya perlu menetapkan pemberat tiga pelayan pertama saya, contohnya, yang pertama ditetapkan kepada 5, yang kedua ditetapkan kepada 1, dan yang pertama ditetapkan kepada 1. Tiga tetapan 1

第一台服务器	192.168.1.1	5
第二台服务器	192.168.1.2	1
第三台服务器	192.168.1.3	1

Pada masa ini, 5 permintaan pertama akan mengakses pelayan pertama, permintaan keenam akan mengakses pelayan kedua dan permintaan ketujuh akan mengakses pelayan ketiga.

Berikut ialah contoh kod yang saya berikan:

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

}

Hasil larian pada masa ini ialah

Yang pertama anda boleh lihat Pelayan pertama telah dilaksanakan 5 kali, 2 pelayan seterusnya telah dilaksanakan sekali, dan seterusnya. Mungkin anda fikir algoritma ini tidak buruk. Malah, satu kelemahan algoritma ini ialah jika berat pelayan pertama terlalu besar, saya mungkin perlu melaksanakan banyak permintaan ke pelayan pertama Dalam kes ini, pengedaran tidak sekata dan akan menyebabkan tekanan pada pelayan tertentu. Saiz yang berlebihan membawa kepada keruntuhan. Jadi saya akan memperkenalkan algoritma ketiga untuk menyelesaikan masalah ini kemudian

Algoritma Pengundian Berwajaran Lancar

Algoritma ini mungkin lebih rumit, dan ia agak mengelirukan apabila saya mula-mula melihatnya. Saya tidak begitu faham saya telah membaca maklumat yang berkaitan kemudian dan menggabungkannya dengan pemahaman saya sendiri untuk menerangkannya dengan gambar dan teks yang saya berikan sebagai contoh di sini

请求	当前权重 = 自身权重+选中后当前权重	总权重	当前最大权重	返回的ip	选中后当前权重=当前最大权重-总权重
1	{5,1,1}	7	5	192.168.1.1	{-2,1,1}
2	{3,2,2}	7	3	192.168.1.1	{-4,2,2}
3	{1,3,3}	7	3	192.168.1.2	{1,-4,3}
4	{6,-3,4}	7	6	192.168.1.1	{-1,-3,4}
5	{4,-2,5}	7	5	192.168.1.3	{4,-2,-2}
6	{9,-1,-1}	7	9	192.168.1.1	{2,-1,-1}
7	{7,0,0}	7	7	192.168.1.1	{0,0,0}

Seperti yang anda boleh lihat dari gambar di atas, Walaupun berat pelayan ditetapkan kepada 5, permintaan kelima tidak dilaksanakan oleh pelayan pertama, tetapi dilaksanakan dengan cara yang diedarkan jujukan adalah sangat sekata, dan berat semasa kembali ke kali ketujuh selepas pemilihan Menjelang {0, 0, 0}, keadaan kejadian adalah konsisten dengan keadaan awal, jadi operasi penjadualan boleh diulang pada masa hadapan.

Sesetengah orang mungkin tidak memahami dengan jelas maksud gambar sebelumnya. Biar saya terangkan secara ringkas di sini:

1 tetapkan berat. Jumlah

2 Apabila permintaan pertama masuk, saya memulakan nilai berat semasa yang dipilih secara lalai kepada {0,0,0}, jadi nilai berat semasa ialah {5+0, 1+0,1 +0}, 5,1,1 di sini ialah pemberat yang ditetapkan oleh setiap pelayan di hadapan kita.

3 Di sini kita boleh membuat kesimpulan bahawa berat maksimum permintaan pertama ialah 5. Kemudian kembali ke ip pelayan pertama

4 Kemudian kami menetapkan berat semasa selepas pemilihan, berikut ialah berat maksimum semasa tolak jumlah berat (5-7), berat yang tidak dipilih kekal tidak berubah dan berat semasa diperolehi pada masa ini Pilih nilai berat {5-7,1,1}

5 Apabila permintaan kedua datang, kami akan meneruskan langkah 2, 3, dan 4 di atas

Jika masih ada Jika anda tidak faham, saya akan menyediakan algoritma yang saya laksanakan menggunakan kod java di bawah:

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

Hasil pelaksanaan kod di sini ialah:

Anda boleh melihat Keputusan pelaksanaan di sini konsisten dengan yang diterangkan dalam jadual.

Atas ialah kandungan terperinci Bagaimana Nginx melaksanakan algoritma pengundian. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!