Nginx的负载算法

轮询

算法思想：在服务器的处理能力相同，请求处理量差异不大的情况下，可以按照负载服务器的顺序均匀的分配给每台服务器，这种均匀分配请的方式成为轮询。

代码实例：

	public static  Map<String, Integer> serverWeightMap = new HashMap<String,Integer>();
	public static Integer pos = 0;
	public  NewTest(String[] args) throws Exception, Exception{
		serverWeightMap.put("192.168.121.12", 1);
		serverWeightMap.put("192.168.121.13", 1);
		serverWeightMap.put("192.168.121.14", 4);
		serverWeightMap.put("192.168.121.15", 1);
		serverWeightMap.put("192.168.121.16", 1);
		serverWeightMap.put("192.168.121.17", 3);
		serverWeightMap.put("192.168.121.18", 1);
		serverWeightMap.put("192.168.121.19", 2);
		serverWeightMap.put("192.168.121.20", 1);
		serverWeightMap.put("192.168.121.21", 1);
		serverWeightMap.put("192.168.121.22", 1);
	}
	//轮询法
    public static String testRoundRobin() throws Exception, IOException {
    	Map<String, Integer> serverMap = new HashMap<String,Integer>();
    	serverMap.putAll(serverWeightMap);
    	Set<String> keySet = serverMap.keySet();
    	ArrayList<String> list = new ArrayList<String>();
    	list.addAll(keySet);
    	String server = "";
    	synchronized (pos) {
			if (pos>=keySet.size()) {
				pos=0;
			}
			server = list.get(pos);
			pos++;
		}
    	return server;
    }

nginx配置：

upstream tomcats {
        server 192.168.0.100:8080;
        server 192.168.0.101:8080;
}

随机

算法思想：客户端的请求到达后台，负载策略会随机性的从负载ip列表中获取一个服务器对请求进行处理。

代码实例：

    //随机算法
    public static String testRandom(){
    	String server = "";
    	Map<String, Integer> serverMap = new HashMap<String,Integer>();
    	serverMap.putAll(serverWeightMap);
    	Set<String> keySet = serverMap.keySet();
    	ArrayList<String> list = new ArrayList<String>();
    	list.addAll(keySet);
    	Random random = new Random();
    	int randomip = random.nextInt(keySet.size());
    	server = list.get(randomip);
    	return server;
    }

加权轮询

算法思想：设置一个列表用来维护负载ip，按照ip的权重将该ip添加到列表中多次，权重是几就要添加几次，客户端的请求会按照顺序分配给ip列表中的某一个ip。

代码实例：

public static String testWeightRoundRobin(){
    	String server = "";
    	Map<String, Integer> serverMap = new HashMap<String,Integer>();
    	serverMap.putAll(serverWeightMap);
    	Set<String> keySet = serverMap.keySet();
    	Iterator<String> iterator = keySet.iterator();
    	ArrayList<String> list = new ArrayList<String>();
    	while(iterator.hasNext()){
    		String ip = iterator.next();
    		Integer weight = serverMap.get(ip);
    		for(int i=0;i<weight;i++){
    			list.add(ip);
    		}
    	}
    	synchronized (pos) {
    		if (pos>=list.size()) {
				pos=0;
			}
    		server = list.get(pos);
    		pos++;
		}
    	return server;
    }

nginx配置：

    upstream back_opencache {
                server 10.159.39.136:12082 weight=2 max_fails=3 fail_timeout=10s;
                server 10.159.39.137:12082 weight=2 max_fails=3 fail_timeout=10s;
        }

加权随机

算法思想：按照每个负载ip的权重来设置在ip列表中出现的概率，比重越大概率越大，同时在客户端请求到达负载时，首先要获取一个随机数，通过随机数来获取负载ip列表中的敷在服务器，权重越大获取到的概率也会越大。。

代码实例：

public static String testWeightRandom() {
		String server = "";
		Map<String, Integer> serverMap = new HashMap<String,Integer>();
		serverMap.putAll(serverWeightMap);
		Set<String> keySet = serverMap.keySet();
		ArrayList<String> list = new ArrayList<String>();
		Iterator<String> iterator = keySet.iterator();
		while(iterator.hasNext()){
			String ip = iterator.next();
			Integer weight = serverMap.get(ip);
			for(int i=0;i<weight;i++){
				list.add(ip);
			}
		}
		Random random = new Random();
		int randomip = random.nextInt(list.size());
		server = list.get(randomip);
		return server;
	}

哈希一致

算法思想：在客户端发送请求时，服务器会判断客户端的ip的hash值，将取到的hash值与负载服务器的总数取模，按照模值获取负载ip列表中的服务器。

代码实例：

public static String testConsumerHash(String ip){
    	String server = "";
    	Map<String, Integer> serverMap = new HashMap<String,Integer>();
    	serverMap.putAll(serverWeightMap);
    	Set<String> keySet = serverMap.keySet();
    	ArrayList<String> list = new ArrayList<String>();
    	int hashCode = ip.hashCode();
    	int serverPos = hashCode%list.size();
    	server = list.get(serverPos);
    	return server;
    }

nginx配置：

    upstream back_openfacade {
		ip_hash;
                server 10.159.39.136:12083;
                server 10.159.39.137:12083;
        }

最小连接数

　　即使后端机器的性能和负载一样，不同客户端请求复杂度不一样导致处理时间也不一样。最小连接数法根据后端服务器当前的连接数情况，动态地选取其中积压连接数最小的一台服务器来处理当前的请求，尽可能提高后端服务器的利用效率，合理地将请求分流到每一台服务器。

nginx配置：

  upstream back_opencache {
                least_conn;
                server 10.159.39.136:12082 weight=2 max_fails=3 fail_timeout=10s;
                server 10.159.39.137:12082 weight=2 max_fails=3 fail_timeout=10s;
        }