几种常见的路由负载均衡算法

package reg_fuzai.fuzai;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

//加权
public class fuzaiDemo {
   //轮询: 从第一个开始循环访问，到最后一个就把position重置为0
   public String fuzaiDemo0() {
       String serverName="";
       //获取所有的服务器
       //要访问的是key。1 代表的是权重
       List<String> list=new ArrayList<String>();
       list.add("192.168.1.1");
       list.add("192.168.1.2");
       list.add("192.168.1.3");
       list.add("192.168.1.4");
       list.add("192.168.1.5");
       Integer position=0;
       synchronized (position) {
           if(position>list.size()) {
               position=0;
           }
           serverName=list.get(position);
           position++;
       }
       return serverName;
   }

   /** 加权轮询：就是说根据服务器的负载性能加权。
* return string:返回服务器名字
*/
public String fuzaiDemo1() {
       String serverName="";
       //获取所有的服务器:   要访问的是key。value代表的是权重,
       Map<String ,Integer> ipMap=new HashMap<String,Integer>();
       ipMap.put("192.168.1.1",1);
       ipMap.put("192.168.1.2",2);
       ipMap.put("192.168.1.3",3);
       ipMap.put("192.168.1.4",4);
       ipMap.put("192.168.1.5",5);
       ipMap.put("192.168.1.6",6);

       Set<String> keySet = ipMap.keySet();
       Iterator<String> iterator = keySet.iterator();
       List<String> list=new ArrayList<String>();
       //加权：如果为了不让服务器在某个时间一直被访问，可以把list里面的数据打乱
       while(iterator.hasNext()) {
           String next = iterator.next();
           Integer quan = ipMap.get(next);
           for(int i=0;i<quan;i++) {
               list.add(next);//如果权重为1，就直接把该服务器添加到list 一个，权重为5，就添加五个服务器的名字到list中
           }
       }
       //轮训
       Integer position=0;
       synchronized (position) {
           if(position>list.size()) {
               position=0;
           }
           serverName=list.get(position);
           position++;
       }
       return serverName;

}

   /* hash负载
   * clientIp : 请求的客户端ip地址
   * 源地址哈希法的优点在于：保证了相同客户端IP地址将会被哈希到同一台后端服务器，
   * 直到后端服务器列表变更。根据此特性可以在服务消费者与服务提供者之间建立有状态的session会话。
   * 源地址哈希算法的缺点在于：除非集群中服务器的非常稳定，基本不会上下线，否则一旦有服务器上线、下线，
   * 那么通过源地址哈希算法路由到的服务器,是服务器上线、下线前路由到的服务器的概率非常低，
   * 如果是session则取不到session，如果是缓存则可能引发"雪崩"。
   * */
public String fuzaiDemo2(String clientIp) {

   Map<String,Integer> ipMap=new ConcurrentHashMap<String,Integer>();
   ipMap.put("192.168.13.1",1);
   ipMap.put("192.168.13.2",2);
   ipMap.put("192.168.13.3",4);

// 2.取出来key,放到set中
Set<String> ipset=ipMap.keySet();

   // 3.set放到list，要循环list取出
   ArrayList<String> iplist=new ArrayList<String>();
   iplist.addAll(ipset);

   //对ip的hashcode值取余数，每次都一样的
   int hashCode=clientIp.hashCode();
   int serverListsize=iplist.size();
   int pos=hashCode%serverListsize;
   return iplist.get(pos);
}

public static void main(String[] args) {
   String clientIp="192.168.1.2";
   String clientIp1="10.2.1.2";
   String clientIp2="192.168.1.2";
   String clientIp3="192.168.1.2";
   String clientIp4="192.168.1.2";
   String clientIp5="192.168.1.2";
   int hashCode=clientIp1.hashCode();
   int serverListsize=3;
   int pos=hashCode%serverListsize;
   System.out.println(pos);
   }
}

几种常见的路由负载均衡算法

猜你喜欢