负载均衡算法

最新推荐文章于 2023-09-20 16:20:00 发布
最新推荐文章于 2023-09-20 16:20:00 发布
阅读量439 收藏 8
点赞数 4
分类专栏： 分布式 文章标签： 负载均衡算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/carson0408/article/details/83932978
版权

        在服务器集群中，需要用负载均衡器在集群中选择合适的服务器进行响应请求，其中负载均衡器通过负载均衡算法来选择服务器的。因此，负载均衡算法的选择会影响服务整体的性能问题。一般，常见的负载均衡算法有轮询法、随机法、源地址哈希法、加权轮询法、加权随机法、最小连接数算法等。

1.轮询法

        轮询法即逐个请求，对于每一个请求，则在地址列表中依次选择一个地址，因此在请求数目上的分配相对比较均衡。

        通过以下示例来进行解释：

轮询方法类：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class RoundRobin {
	
	private static final ArrayList<String> arr = new ArrayList<>();
	private static Integer pos = 0;
	static {
		
		arr.add("192.168.1.100");
		arr.add("192.168.1.101");
		arr.add("192.168.1.102");
		arr.add("192.168.1.103");
		arr.add("192.168.1.104");
		arr.add("192.168.1.105");
		arr.add("192.168.1.106");
		arr.add("192.168.1.107");
		arr.add("192.168.1.108");
		arr.add("192.168.1.109");
		arr.add("192.168.1.110");
		
	}
	//轮询法获取ip
	public static String testRoundRobin(int requestId) {
		
		
		
		String server = null;
		
		synchronized (pos) {
			if(pos>=arr.size())
				pos = 0;
			server = arr.get(pos);
			pos++;
		}
		return requestId+"响应的服务器ip是:"+server;
		
		
	}

}

轮询工作线程类：

public class GetServerThread extends Thread {
	private String server = null;
	public int requestId ;
	public GetServerThread(int requestId) {
		// TODO Auto-generated constructor stub
		this.requestId = requestId;
	}
	@Override
	public void run() {
		synchronized (this) {
			server = RoundRobin.testRoundRobin(requestId);
			System.out.println(server);
			
		}
	}
}

测试类：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Test {

	public static void main(String[] args) throws InterruptedException {
		// TODO Auto-generated method stub
		ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(5, 10, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(100));
		for(int i=0;i<30;i++) {
			Thread thread = new GetServerThread(i+1);
			thread.start();
			thread.join();
		}
		
	}

}

运行程序测试结果如下：

1响应的服务器ip是:192.168.1.100
2响应的服务器ip是:192.168.1.101
3响应的服务器ip是:192.168.1.102
4响应的服务器ip是:192.168.1.103
5响应的服务器ip是:192.168.1.104
6响应的服务器ip是:192.168.1.105
7响应的服务器ip是:192.168.1.106
8响应的服务器ip是:192.168.1.107
9响应的服务器ip是:192.168.1.108
10响应的服务器ip是:192.168.1.109
11响应的服务器ip是:192.168.1.110
12响应的服务器ip是:192.168.1.100
13响应的服务器ip是:192.168.1.101
14响应的服务器ip是:192.168.1.102
15响应的服务器ip是:192.168.1.103
16响应的服务器ip是:192.168.1.104
17响应的服务器ip是:192.168.1.105
18响应的服务器ip是:192.168.1.106
19响应的服务器ip是:192.168.1.107
20响应的服务器ip是:192.168.1.108
21响应的服务器ip是:192.168.1.109
22响应的服务器ip是:192.168.1.110
23响应的服务器ip是:192.168.1.100
24响应的服务器ip是:192.168.1.101
25响应的服务器ip是:192.168.1.102
26响应的服务器ip是:192.168.1.103
27响应的服务器ip是:192.168.1.104
28响应的服务器ip是:192.168.1.105
29响应的服务器ip是:192.168.1.106
30响应的服务器ip是:192.168.1.107

        由以上结果可以看出，30个请求依次在列表中进行分配，因此相对来说，每个服务器分配到的请求数比较均衡。

2.随机法

        随机法则是随机分配给地址列表中的任一服务器。这个例子则通过随机生成列表长度内的一个整数，然后获取其地址来实现的。

随机方法类：

import java.util.ArrayList;
import java.util.Random;



public class RandomMethod {
	private static final ArrayList<String> arr = new ArrayList<>();
	private static Integer pos = 0;
	
	
	static {
		arr.add("192.168.1.100");
		arr.add("192.168.1.101");
		arr.add("192.168.1.102");
		arr.add("192.168.1.103");
		arr.add("192.168.1.104");
		arr.add("192.168.1.105");
		arr.add("192.168.1.106");
		arr.add("192.168.1.107");
		arr.add("192.168.1.108");
		arr.add("192.168.1.109");
		arr.add("192.168.1.110");
	}
	public static String testRandom(int requestId) {
		String server = null;
		synchronized (pos) {
			Random random = new Random();
			pos=random.nextInt(arr.size());
			server = arr.get(pos);
		}

		return "响应请求"+requestId+"的服务器ip是:"+server;
		
	}
}

线程类：

public class GetRandomThread extends Thread{

	private static int requestId;
	public GetRandomThread(int requestId) {
		// TODO Auto-generated constructor stub
		this.requestId = requestId;
	}
	
	public void run() {
		synchronized (this) {
			
			String server = RandomMethod.testRandom(requestId);
			System.out.println(server);
		}
	}

}

测试类：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;



public class Test {

	public static void main(String[] args) throws InterruptedException {
		// TODO Auto-generated method stub
		ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(5, 10, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(100));
		for(int i=0;i<30;i++) {
			Thread thread = new GetRandomThread(i+1);
			thread.start();
			thread.join();
		}
		
	}

}

运行结果：

响应请求1的服务器ip是:192.168.1.102
响应请求2的服务器ip是:192.168.1.105
响应请求3的服务器ip是:192.168.1.102
响应请求4的服务器ip是:192.168.1.105
响应请求5的服务器ip是:192.168.1.106
响应请求6的服务器ip是:192.168.1.109
响应请求7的服务器ip是:192.168.1.106
响应请求8的服务器ip是:192.168.1.105
响应请求9的服务器ip是:192.168.1.107
响应请求10的服务器ip是:192.168.1.101
响应请求11的服务器ip是:192.168.1.108
响应请求12的服务器ip是:192.168.1.100
响应请求13的服务器ip是:192.168.1.106
响应请求14的服务器ip是:192.168.1.109
响应请求15的服务器ip是:192.168.1.105
响应请求16的服务器ip是:192.168.1.104
响应请求17的服务器ip是:192.168.1.103
响应请求18的服务器ip是:192.168.1.101
响应请求19的服务器ip是:192.168.1.107
响应请求20的服务器ip是:192.168.1.110
响应请求21的服务器ip是:192.168.1.110
响应请求22的服务器ip是:192.168.1.110
响应请求23的服务器ip是:192.168.1.108
响应请求24的服务器ip是:192.168.1.107
响应请求25的服务器ip是:192.168.1.103
响应请求26的服务器ip是:192.168.1.106
响应请求27的服务器ip是:192.168.1.108
响应请求28的服务器ip是:192.168.1.107
响应请求29的服务器ip是:192.168.1.109
响应请求30的服务器ip是:192.168.1.103

        根据运行结果来看，随机法分配并没有一定规律。但是当吞吐量比较大的时候，随机法结果接近于轮询法。

3.源地址哈希法

        该方法通过对发送请求的客户端的ip地址进行求hash值，并对服务地址列表长度取余，选择结果对应的服务器。该方法保证了同一客户端ip地址会被映射到相同的后端服务器上，直到后端服务器列表发生了改变。根据这个特性，可以在服务消费者和服务提供者之间建立有状态的session会话。

源地址哈希法类：

import java.util.ArrayList;

public class HashMthod {
	private static final ArrayList<String> arr = new ArrayList<>();
	private static Integer pos = 0;
	
	
	static {
		arr.add("192.168.1.100");
		arr.add("192.168.1.101");
		arr.add("192.168.1.102");
		arr.add("192.168.1.103");
		arr.add("192.168.1.104");
		arr.add("192.168.1.105");
		arr.add("192.168.1.106");
		arr.add("192.168.1.107");
		arr.add("192.168.1.108");
		arr.add("192.168.1.109");
		arr.add("192.168.1.110");
	}
	
	public static String testConsumerHash(String consumerIP) {
		String server = null;
		synchronized (pos) {
			pos = Math.abs(consumerIP.hashCode())%arr.size();
			
			server = arr.get(pos);
			
		}
		return consumerIP+"的响应的服务器ip是:"+server;
	}

}

线程类：

public class GetHashThread extends Thread {
	private String consumerIP;
	public GetHashThread(String consumerIP) {
		this.consumerIP = consumerIP;
	}
	public void run() {
		synchronized (this) {
			String server = HashMthod.testConsumerHash(consumerIP);
			System.out.println(server);
			
		}
	}

}

测试类：

import java.util.Random;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;



public class Test {

	public static void main(String[] args) throws InterruptedException {
		// TODO Auto-generated method stub
		ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(5, 10, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(100));
		Random random = new Random();
		for(int i=0;i<30;i++) {
			int rand = random.nextInt(255);
			Thread thread = new GetHashThread("192.168.111."+rand);
			thread.start();
			thread.join();
		}
		
	}

}

运行结果：

192.168.111.220的响应的服务器ip是:192.168.1.110
192.168.111.236的响应的服务器ip是:192.168.1.103
192.168.111.25的响应的服务器ip是:192.168.1.110
192.168.111.209的响应的服务器ip是:192.168.1.101
192.168.111.31的响应的服务器ip是:192.168.1.104
192.168.111.165的响应的服务器ip是:192.168.1.103
192.168.111.130的响应的服务器ip是:192.168.1.104
192.168.111.154的响应的服务器ip是:192.168.1.104
192.168.111.172的响应的服务器ip是:192.168.1.109
192.168.111.14的响应的服务器ip是:192.168.1.100
192.168.111.30的响应的服务器ip是:192.168.1.103
192.168.111.223的响应的服务器ip是:192.168.1.102
192.168.111.138的响应的服务器ip是:192.168.1.101
192.168.111.30的响应的服务器ip是:192.168.1.103
192.168.111.185的响应的服务器ip是:192.168.1.110
192.168.111.229的响应的服务器ip是:192.168.1.108
192.168.111.42的响应的服务器ip是:192.168.1.103
192.168.111.221的响应的服务器ip是:192.168.1.100
192.168.111.134的响应的服务器ip是:192.168.1.108
192.168.111.17的响应的服务器ip是:192.168.1.103
192.168.111.49的响应的服务器ip是:192.168.1.110
192.168.111.231的响应的服务器ip是:192.168.1.109
192.168.111.30的响应的服务器ip是:192.168.1.103
192.168.111.90的响应的服务器ip是:192.168.1.102
192.168.111.26的响应的服务器ip是:192.168.1.100
192.168.111.131的响应的服务器ip是:192.168.1.105
192.168.111.156的响应的服务器ip是:192.168.1.106
192.168.111.207的响应的服务器ip是:192.168.1.110
192.168.111.190的响应的服务器ip是:192.168.1.103
192.168.111.146的响应的服务器ip是:192.168.1.108

        根据以上结果可以看出，出现了多次ip：192.168.111.30，最终响应的服务器都是192.168.1.103.验证了相同客户端ip可以映射到同一后端服务器。

4.加权轮询法

        加权轮询法则是给每个服务器都设置了权重，配置低、负载高的服务器权重低，配置高、负载低的服务器权重高。这说明应该让权重高的服务器接收到请求的概率更高。因此可以根据权重在列表中复制相同ip地址，然后根据轮询法来选择相应ip地址，可以满足权重高的被选择的概率相对较高。

加权轮询法类:

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class WeightRoundRobin {
	private static final ArrayList<String> arr = new ArrayList<>();
	private static final HashMap<String, Integer> serverWeight = new HashMap<>();
	private static Integer pos = 0;
	static {
		serverWeight.put("192.168.1.100", 1);
		serverWeight.put("192.168.1.101", 1);
		
		serverWeight.put("192.168.1.102", 4);
		serverWeight.put("192.168.1.103", 1);
		serverWeight.put("192.168.1.104", 1);
		
		serverWeight.put("192.168.1.105", 3);
		serverWeight.put("192.168.1.106", 1);
		
		serverWeight.put("192.168.1.107", 2);
		serverWeight.put("192.168.1.108", 1);
		serverWeight.put("192.168.1.109", 1);
		serverWeight.put("192.168.1.110", 1);
		
		//重新创建一个map，避免出现由于服务器上线和下线导致的并发问题
		Map<String, Integer> serverMap = new HashMap<>();
		serverMap.putAll(serverWeight);
		
		//取得IP地址list
		Set<String> keySet = serverMap.keySet();
		Iterator<String> it = keySet.iterator();
		while(it.hasNext()) {
			String server = it.next();
			Integer weight = serverWeight.get(server);
			for(int i=0;i<weight;i++) {
				arr.add(server);
			}
		}
	}
	
	public static String testWeightRoundRobin(int requestId) {
		String server = null;
		synchronized (pos) {
			if(pos>=arr.size())
				pos = 0;
			server = arr.get(pos);
			pos++;
		}
		return "响应请求"+requestId+"的服务器ip是:"+server;
	}
	

}

线程类：

public class GetWeightRoundRobin extends Thread{
	private int requestId;
	public GetWeightRoundRobin(int requestId) {
		// TODO Auto-generated constructor stub
		this.requestId = requestId;
	}
	
	
	public void run() {
		synchronized (this) {
			String server = WeightRoundRobin.testWeightRoundRobin(requestId);
			System.out.println(server);
		}
	}

}

测试类:

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;



public class Test {

	public static void main(String[] args) throws InterruptedException {
		// TODO Auto-generated method stub
		ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(5, 10, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(100));
		for(int i=0;i<30;i++) {
			Thread thread = new GetWeightRoundRobin(i+1);
			thread.start();
			thread.join();
		}
		
	}

}

运行结果：

响应请求1的服务器ip是:192.168.1.107
响应请求2的服务器ip是:192.168.1.107
响应请求3的服务器ip是:192.168.1.108
响应请求4的服务器ip是:192.168.1.109
响应请求5的服务器ip是:192.168.1.103
响应请求6的服务器ip是:192.168.1.104
响应请求7的服务器ip是:192.168.1.105
响应请求8的服务器ip是:192.168.1.105
响应请求9的服务器ip是:192.168.1.105
响应请求10的服务器ip是:192.168.1.106
响应请求11的服务器ip是:192.168.1.110
响应请求12的服务器ip是:192.168.1.100
响应请求13的服务器ip是:192.168.1.101
响应请求14的服务器ip是:192.168.1.102
响应请求15的服务器ip是:192.168.1.102
响应请求16的服务器ip是:192.168.1.102
响应请求17的服务器ip是:192.168.1.102
响应请求18的服务器ip是:192.168.1.107
响应请求19的服务器ip是:192.168.1.107
响应请求20的服务器ip是:192.168.1.108
响应请求21的服务器ip是:192.168.1.109
响应请求22的服务器ip是:192.168.1.103
响应请求23的服务器ip是:192.168.1.104
响应请求24的服务器ip是:192.168.1.105
响应请求25的服务器ip是:192.168.1.105
响应请求26的服务器ip是:192.168.1.105
响应请求27的服务器ip是:192.168.1.106
响应请求28的服务器ip是:192.168.1.110
响应请求29的服务器ip是:192.168.1.100
响应请求30的服务器ip是:192.168.1.101

        从运行结果可以看出，权重较高的服务器出现的频率相对较高。

5.加权随机法

        该方法的转换思路与加权轮询法一致，只不过后面一步是用随机法。

加权随机法类:

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Random;
import java.util.Set;

public class WeightRandom {
	private static final ArrayList<String> arr = new ArrayList<>();
	private static final HashMap<String, Integer> serverWeight = new HashMap<>();
	private static Integer pos = 0;
	static {
		serverWeight.put("192.168.1.100", 1);
		serverWeight.put("192.168.1.101", 1);
		
		serverWeight.put("192.168.1.102", 4);
		serverWeight.put("192.168.1.103", 1);
		serverWeight.put("192.168.1.104", 1);
		
		serverWeight.put("192.168.1.105", 3);
		serverWeight.put("192.168.1.106", 1);
		
		serverWeight.put("192.168.1.107", 2);
		serverWeight.put("192.168.1.108", 1);
		serverWeight.put("192.168.1.109", 1);
		serverWeight.put("192.168.1.110", 1);
		
		//重新创建一个map，避免出现由于服务器上线和下线导致的并发问题
		Map<String, Integer> serverMap = new HashMap<>();
		serverMap.putAll(serverWeight);
		
		//取得IP地址list
		Set<String> keySet = serverMap.keySet();
		Iterator<String> it = keySet.iterator();
		while(it.hasNext()) {
			String server = it.next();
			Integer weight = serverWeight.get(server);
			for(int i=0;i<weight;i++) {
				arr.add(server);
			}
		}
	}
	public static String testWeightRandom(int requestId) {
		// TODO Auto-generated method stub
		String server = null;
		synchronized (pos) {
			Random random = new Random();
			pos = random.nextInt(arr.size());
			server = arr.get(pos);
		}
		return "响应请求"+requestId+"的服务器ip是:"+server;
	}
}

线程类：

public class GetWeightRandomThread extends Thread{
	private int requestId;
	public GetWeightRandomThread(int requestId) {
		// TODO Auto-generated constructor stub
		this.requestId = requestId;
	}
	
	public void run() {
		synchronized (this) {
			String server = WeightRandom.testWeightRandom(requestId);
			System.out.println(server);
			
		}
	}

}

测试类：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;



public class Test {

	public static void main(String[] args) throws InterruptedException {
		// TODO Auto-generated method stub
		ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(5, 10, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(100));
		for(int i=0;i<30;i++) {
			Thread thread = new GetWeightRandomThread(i+1);
			thread.start();
			thread.join();
		}
		
	}
}

运行结果：

响应请求1的服务器ip是:192.168.1.107
响应请求2的服务器ip是:192.168.1.107
响应请求3的服务器ip是:192.168.1.108
响应请求4的服务器ip是:192.168.1.109
响应请求5的服务器ip是:192.168.1.103
响应请求6的服务器ip是:192.168.1.104
响应请求7的服务器ip是:192.168.1.105
响应请求8的服务器ip是:192.168.1.105
响应请求9的服务器ip是:192.168.1.105
响应请求10的服务器ip是:192.168.1.106
响应请求11的服务器ip是:192.168.1.110
响应请求12的服务器ip是:192.168.1.100
响应请求13的服务器ip是:192.168.1.101
响应请求14的服务器ip是:192.168.1.102
响应请求15的服务器ip是:192.168.1.102
响应请求16的服务器ip是:192.168.1.102
响应请求17的服务器ip是:192.168.1.102
响应请求18的服务器ip是:192.168.1.107
响应请求19的服务器ip是:192.168.1.107
响应请求20的服务器ip是:192.168.1.108
响应请求21的服务器ip是:192.168.1.109
响应请求22的服务器ip是:192.168.1.103
响应请求23的服务器ip是:192.168.1.104
响应请求24的服务器ip是:192.168.1.105
响应请求25的服务器ip是:192.168.1.105
响应请求26的服务器ip是:192.168.1.105
响应请求27的服务器ip是:192.168.1.106
响应请求28的服务器ip是:192.168.1.110
响应请求29的服务器ip是:192.168.1.100
响应请求30的服务器ip是:192.168.1.101

6.最小连接数算法

         由于前面几个算法基本只考虑了请求数上的负载均衡，而没有考虑到每个请求处理时长的不同，所以也许实际并不这样。因此最小连接数算法更合适实际场景。最小连接数根据每个服务器当前连接的请求数来选择连接请求数最小的服务器。因此该算法需要为每个服务器地址维护一个连接数变量来记录当前该服务器连接的请求数，当有新请求连接，以及请求处理结束都需要改变该值。

carson0408
关注
  • 4
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
弹性负载均衡（Elastic Load Balance，ELB）
coco3600的博客
06-21 4150
弹性负载均衡（Elastic Load Balance，ELB） https://support.huaweicloud.com/elb/index.html 弹性负载均衡（Ela...
一种改进的动态反馈负载均衡算法
04-16
在集群系统中，负载均衡算法是影响系统性能的关键因素之一。为了进一步提高集群系统的性能，有必要对负载均衡算法进行优化。通过对最小连接算法和DFB（Dynamic Feed-Back）算法的详细分析，提出了一种改进的动态反馈...
6种负载均衡算法
小技术君
03-04 2184
当今的分布式系统越来越普遍，由于它们能够提供更高的灵活性和可扩展性。但是，这些系统需要处理大量的客户端请求。为了处理这些请求并提供对每个客户端的稳定和高效的服务，需要使用负载均衡算法。以下是分布式系统中常用的负载均衡算法：????静态算法1.轮询（Round Robin）：将客户端请求按顺序发送到不同的服务实例。服务通常需要是无状态的。2.粘性轮询（Sticky Round Robin）：是轮询算法的改...
常见的负载均衡算法
HHH的博客
08-20 210
负载均衡算法也是分布式系统中的重要组成部分，用于将来自客户端的请求分配到不同的后端服务器上，以达到提高系统吞吐量、减轻服务器负担、提高系统可用性等目的。
负载均衡获得真实源IP的6种方法
weixin_33721344的博客
11-17 1184
除了X-FORWARD-FOR，负载均衡中获得真实源IP的方法还有很多种。本文抛砖引玉，主要介绍获得真实源IP的多种方法，而不是具体配置。负载均衡获得真实IP的方法有很多种，将形成专题文章。本文为第一篇，主要做介绍和优劣对比。小慢哥的原创文章，欢迎转载获得真实IP的6种方法当数据包从负载均衡器往后端转发时候，真实源IP可在L3、L4、L7实现，并且分别有2种方法可以获得...
F5负载均衡算法标准详解
09-28
【F5负载均衡算法标准详解】 在IT领域，负载均衡是一种关键的技术，它确保网络流量在多台服务器间均匀分布，提高系统可用性和性能。F5作为业界领先的应用交付控制器（ADC）提供商，其负载均衡解决方案以其高效和...
负载均衡算法.docx
05-08
以下是关于负载均衡算法的详细解释： 1. **轮循均衡**（Round Robin）是最基础的负载均衡算法，每次新请求都会被分配给服务器列表中的下一个服务器，形成循环。这种方法适合服务器性能相当且处理请求均匀的情况。 ...
Dubbo的负载均衡算法.docx
11-06
【Dubbo的负载均衡算法】 在分布式服务框架Dubbo中，负载均衡算法是核心功能之一，用于在集群中均匀分配请求，确保服务的稳定性和高效性。Dubbo提供了四种负载均衡策略，分别是Random LoadBalance（随机算法）、...
Balancing_负载均衡算法_
10-03
在给定的“Balancing_负载均衡算法_”压缩包中，我们可以推测这可能包含了一套基于C语言实现的负载均衡算法，适用于Visual Studio 2013开发环境。 负载均衡的基本目标是将工作负载分散到多个计算资源，如服务器、...
转：典型的几个负载均衡算法---SLB
05-11
SLB 算法.典型的几个负载均衡算法典型的几个负载均衡算法典型的几个负载均衡算法典型的几个负载均衡算法
今天来聊一聊常见的负载均衡算法
chenmuchen_的博客
09-20 200
本文介绍了常见的负载均衡算法，包括轮询、随机、加权、最小连接数和哈希算法，并分别说明了它们的原理和适用场景。每个节点的权重值根据其性能差异进行设置，性能好的节点设置较大的权重，而性能差的节点则设置较小的权重。随机算法是一种将请求随机分配到集群中的某个节点上的负载均衡算法。由于随机算法的特性，随着请求量的增加，各个节点处理请求的数量会趋于平衡，即演变为轮询算法。在本文中，我们将讨论常见的负载均衡算法，包括轮询、随机、加权、最小连接数和哈希算法，并介绍它们的原理和适用场景。二、随机算法（Random）
负载均衡之源地址Hash
实践求真知
01-15 1850
一 算法 源地址 Hash 是根据客户端的 IP 地址，通过 Hash 函数的运算把 IP 地址转换为一个固定的数字。根据“Hash”后的数字，对服务器列表进行取模运算，得到服务器的序号。 这种算法的好处是，同一个 IP 地址所选择的服务器总是相同的。相同服务器本地缓存数据，对于有状态的服务来说，每次访问都会命中缓存。 除了源地址 Hash 外，还有目标地址 Hash，它和源地址 Hash 的原理类似。 下图是按源地址进行 Hash 运算后，后端分配的请求情况。 二 实现 package
路由策略实现源地址的负载均衡
weixin_34378969的博客
04-11 348
路由策略实现源地址的负载均衡 通过配置route-map 实现路由策略 并且应用在R2的s1/0端口上，实现居于源地址的不同路由选择~！！！亦可实现居于源地址的负载均衡·！！！ 按照拓扑配置好各个路由器，运行OSPF路由协议！ 各个路由器先配置如下： ===========================================...
负载均衡算法-权重
beiduofen2011的专栏
04-18 516
package com.fen.fou.quanzhong; import java.util.Arrays; import java.util.List; import java.util.Random; import java.util.concurrent.atomic.AtomicInteger; class Server { private String ip; private int port; private int weight; public ..
nginx负载均衡的6种算法
做技术，贵在学习与坚持！
12-28 2792
Nginx 是一个很强大的高性能Web和反向代理服务，它具有很多非常优越的特性： 在连接高并发的情况下，Nginx是Apache服务不错的替代品：Nginx在美国是做虚拟主机生意的老板们经常选择的软件平台之一。能够支持高达 50,000 个并发连接数的响应，感谢Nginx为我们选择了 epoll and kqueue作为开发模型。 下面是五种负载均衡算法： round robin（默认） weight IP_hash url_hash（第三方） fair（第三方） 1.round r...
负载均衡之IP
qq_26249609的博客
10-09 5256
首先让我们来看看下面这张大家都非常熟悉的TCP/IP协议族的分层图： 关于每层在网络数据包传输过程中所起到的作用不是本文的重点，本文主要是讲解如何在网络层中使用IP来做服务器集群的负载均衡，为什么可以在这一层来做负载均衡。下面在来看IP协议的报头格式： 内红色框内的源地址和目的地址是IP负载均衡功能的关键所在，IP负载均衡又可以称之为网络层负载均衡，其核心原理就是通过内核驱动更改IP的目的地址...
配置多个ip地址时源ip的选择
老张的自言自语
09-02 2165
如果一个主机绑定有多个 IP地址，那么在被动响应和主动发起连接两种方式中，源 IP 地址的选择机制肯定是有所差异的。   主机在接收外部数据包，并发送响应数据包时，响应源地址显然就是客户端请求的地址，这是非常容易理解的，如客户端向主机的1.1.2.3:80 发起请求，那么主机响应数据包的源 IP 地址一定是 1.1.2.3 。   那么当主机对外主动发起请求时，数据包的源IP 地址...
WiFi中负载均衡算法
最新发布
02-04
WiFi中的负载均衡算法是用于在多个无线接入点（AP）之间分配用户设备的负载，以实现网络资源的均衡利用和提高用户体验。以下是几种常见的WiFi负载均衡算法： 1. 基于信号强度的负载均衡：该算法根据用户设备与各个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值