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