加权轮询
后端集群每台机器都分配一个权重，权重高得会承担更多的流量，相反权重低的分配的流量也会少，这种策略允许后端集群机器配置差异化
java实现
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 org.springframework.stereotype.Controller;
@Controller
public class IpMapController extends LogBaseController implements Runnable {
private static Integer pos = 0;
// 待scp的Ip列表，Key代表Ip，Value代表该Ip的权重
public static HashMap serverWeightMap = new HashMap();
static {
serverWeightMap.put("127.0.0.1", 1);
serverWeightMap.put("127.0.0.2", 1);
serverWeightMap.put("127.0.0.3", 1);
serverWeightMap.put("127.0.0.4", 1);
}
public void run() {
// 重建一个Map，避免服务器的上下线导致的并发问题
Map serverMap = new HashMap();
serverMap.putAll(serverWeightMap);
// 取得Ip地址List
Set keySet = serverMap.keySet();
Iterator iterator = keySet.iterator();
// 根据权重组成iplist
List serverList = new ArrayList();
while (iterator.hasNext()) {
String server = iterator.next();
int weight = serverMap.get(server);
for (int i = 0; i < weight; i++)
serverList.add(server);
}
String server = null;
synchronized (pos) {
if (pos >= keySet.size()){
pos = 0;
}
server = serverList.get(pos);
System.out.println("server:" + server + ",pos=" + pos);
pos++;
}
}
public static void main(String[] args) {
IpMapController ipRunnable = new IpMapController();
for (int i = 0; i <= 10; i++) {
System.out.println("t" + i);
new Thread(ipRunnable).start();
}
}
}
多线程输出结果
t0
t1
t2
t3
t4
t5
t6
server:127.0.0.4,pos=0
server:127.0.0.3,pos=1
server:127.0.0.2,pos=2
server:127.0.0.2,pos=2
t7
server:127.0.0.4,pos=0
server:127.0.0.3,pos=1
t8
server:127.0.0.2,pos=2
server:127.0.0.2,pos=2
t9
server:127.0.0.4,pos=0
t10
server:127.0.0.3,pos=1
server:127.0.0.2,pos=2
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持脚本之家。

加权轮询
后端集群每台机器都分配一个权重，权重高得会承担更多的流量，相反权重低的分配的流量也会少，这种策略允许后端集群机器配置差异化
java实现
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 org.springframework.stereotype.Controller;
@Controller
public class IpMapController extends LogBaseController implements Runnable {
private static Integer pos = 0;
// 待scp的Ip列表，Key代表Ip，Value代表该Ip的权重
public static HashMap serverWeightMap = new HashMap();
static {
serverWeightMap.put("127.0.0.1", 1);
serverWeightMap.put("127.0.0.2", 1);
serverWeightMap.put("127.0.0.3", 1);
serverWeightMap.put("127.0.0.4", 1);
}
public void run() {
// 重建一个Map，避免服务器的上下线导致的并发问题
Map serverMap = new HashMap();
serverMap.putAll(serverWeightMap);
// 取得Ip地址List
Set keySet = serverMap.keySet();
Iterator iterator = keySet.iterator();
// 根据权重组成iplist
List serverList = new ArrayList();
while (iterator.hasNext()) {
String server = iterator.next();
int weight = serverMap.get(server);
for (int i = 0; i < weight; i++)
serverList.add(server);
}
String server = null;
synchronized (pos) {
if (pos >= keySet.size()){
pos = 0;
}
server = serverList.get(pos);
System.out.println("server:" + server + ",pos=" + pos);
pos++;
}
}
public static void main(String[] args) {
IpMapController ipRunnable = new IpMapController();
for (int i = 0; i <= 10; i++) {
System.out.println("t" + i);
new Thread(ipRunnable).start();
}
}
}
多线程输出结果
t0
t1
t2
t3
t4
t5
t6
server:127.0.0.4,pos=0
server:127.0.0.3,pos=1
server:127.0.0.2,pos=2
server:127.0.0.2,pos=2
t7
server:127.0.0.4,pos=0
server:127.0.0.3,pos=1
t8
server:127.0.0.2,pos=2
server:127.0.0.2,pos=2
t9
server:127.0.0.4,pos=0
t10
server:127.0.0.3,pos=1
server:127.0.0.2,pos=2

负载均衡系列专题
本节我们来看一下如何实现一负载均衡框架。
源码
核心接口定义
public interface ILoadBalance {
/**
* 选择下一个节点
*
* 返回下标
* @param context 上下文
* @return 结果
* @since 0.0.1
*/
IServer select(final ILoadBalanceContext context);
}
1. 随机策略
public class LoadBalanceRandom extends AbstractLoadBalance{
public LoadBalanceRandom(List servers) {
super(servers);
}
@Override
protected IServer doSelect(ILoadBalanceContext context) {
Random random = ThreadLocalRandom.current();
int nextIndex = random.nextInt(servers.size());
return servers.get(nextIndex);
}
}
2. 轮训
public class LoadBalanceRoundRobbin extends AbstractLoadBalance {
/**
* 位移指针
* @since 0.0.1
*/
private final AtomicLong indexHolder = new AtomicLong();
public LoadBalanceRoundRobbin(List servers) {
super(servers);
}
@Override
protected IServer doSelect(ILoadBalanceContext context) {
long index = indexHolder.getAndIncrement();
int actual = (int) (index % servers.size());
return servers.get(actual);
}
}
3. 有权重的轮训
这个需要对数据进行初始化处理，计算数组的最大公约数。
public class LoadBalanceWeightRoundRobbin extends AbstractLoadBalance {
/**
* 位移指针
* @since 0.0.1
*/
private final AtomicLong indexHolder = new AtomicLong();
/**
* 处理后的列表
* @since 0.0.1
*/
private final List actualList = new ArrayList<>();
public LoadBalanceWeightRoundRobbin(List servers) {
super(servers);
// 初始化真实列表
this.init(servers);
}
@Override
protected IServer doSelect(ILoadBalanceContext context) {
long index = indexHolder.getAndIncrement();
// 基于真实的列表构建
int actual = (int) (index % actualList.size());
return actualList.get(actual);
}
/**
* 初始化
* @param serverList 服务列表
* @since 0.0.1
*/
private void init(final List serverList) {
//1. 过滤掉权重为 0 的机器
List notZeroServers = CollectionUtil.filterList(serverList, new IFilter() {
@Override
public boolean filter(IServer iServer) {
return iServer.weight() <= 0;
}
});
//2. 获取权重列表
List weightList = CollectionUtil.toList(notZeroServers, new IHandler() {
@Override
public Integer handle(IServer iServer) {
return iServer.weight();
}
});
//3. 获取最大的权重
int maxDivisor = MathUtil.ngcd(weightList);
//4. 重新计算构建基于权重的列表
for(IServer server : notZeroServers) {
int weight = server.weight();
int times = weight / maxDivisor;
for(int i = 0; i < times; i++) {
actualList.add(server);
}
}
}
}
4. 普通哈希
public class LoadBalanceCommonHash extends AbstractLoadBalanceHash {
public LoadBalanceCommonHash(List servers, IHash hash) {
super(servers, hash);
}
@Override
protected IServer doSelect(ILoadBalanceContext context) {
final String hashKey = context.hashKey();
int hashCode = Math.abs(hash.hash(hashKey));
int index = servers.size() % hashCode;
return servers.get(index);
}
}
5. 一致性哈希
这里将我们前面实现的一致性哈希，与负载均衡结合。
public class LoadBalanceConsistentHash extends AbstractLoadBalanceHash {
/**
* 一致性 hash 实现
* @since 0.0.1
*/
private final IConsistentHashing consistentHashing;
public LoadBalanceConsistentHash(List servers, IHash hash) {
super(servers, hash);
this.consistentHashing = ConsistentHashingBs
.newInstance()
.hash(hash)
.nodes(servers)
.build();
}
@Override
protected IServer doSelect(ILoadBalanceContext context) {
final String hashKey = context.hashKey();
return consistentHashing.get(hashKey);
}
}
后期 Road-Map
还有基于系统最小压力，最小连接的实现，暂时没有放在这里。
后续将加入对应的实现。
完整开源代码
其他还有一些引导类等辅助工具。

一、nginx的 4 种负载均衡算法

1.轮询机制（默认）

    每次请求按照时间顺序逐一分配到不同的后端服务器，假如有后端服务器挂掉，能够自动剔除该服务，使用下一服务，nginx默认使用轮询算法。

    下面中server后面的IP可以配置不同的IP不同端口。

upstream backserver {
    server 127.0.0.1:8080;
    server 127.0.0.1:8090;
}

2.指定权重 weight

    指定轮询的比例，weight和访问比率成正比，用于后端服务器性能不同，有一定差距的情况。

    weight 的值与访问比率成正比，值越大被访问比例就会越高，比如8080的服务访问一次，8090服务会访问两次。

upstream backserver {
    server 127.0.0.1:8080  weight=1;
    server 127.0.0.1:8090  weight=2;
}

3.依据ip分配方式  ip_hash

   当有多个服务器存在时，如果客户第一登录在第一个服务器，第二次请求时要是访问到了另一个服务器时，那么其登录信息就会丢失。

    指定负载均衡器按照基于客户端IP的分配方式，这个方法确保了相同的客户端的请求一直发送到相同的服务器，以保证session会话。这样每个访客都固定访问一个后端服务器，可以解决session不能跨服务器的问题。

upstream backserver {
    ip_hash;
    server 127.0.0.1:8080;
    server 127.0.0.1:8090;
}

4、最少连接 least_conn

    最少连接是每次请求都将请求分发给后台服务连接数最少的那台服务上，配置如下：

     upstream backserver {
		least_conn;
		server 127.0.0.1:8080  ;
		server 127.0.0.1:8090  ;
    }

   上面的配置只是加了一个调度策略 least_conn，其他和轮询的方式一样，当然你也可以给根据服务器性能的不同加上权重比例，分发时就会选择 conn / weight 值最小的那台服务，这种方式适合请求处理时间长短不一造成服务器过载的情况。

   upstream backserver {
		least_conn;
		server 127.0.0.1:8080  weight=2;
		server 127.0.0.1:8090  ;
    }

二、Windows下nginx的相关命令

进入到nginx的安装目录，如下：

E:\Program Files\nginx\nginx-1.17.2>

可以在安装目录的地址栏直接输入cmd 然后回车即可：





Windows下启动nginx

E:\Program Files\nginx\nginx-1.17.2>  start nginx

重新载入Nginx：

E:\Program Files\nginx\nginx-1.17.2>nginx.exe -s reload

E:\Program Files\nginx\nginx-1.17.2>nginx -s reload

停止nginx服务：

E:\Program Files\nginx\nginx-1.17.2>nginx.exe -s stop

E:\Program Files\nginx\nginx-1.17.2>nginx -s stop

 

三、基本配置

1.首先在 C:\Windows\System32\drivers\etc 的host文件中配置一个本地域名如

127.0.0.1  www.testnginx.com



2.编写代码创建两个服务

第一个服务中使用8080端口，第二个服务使用8090端口即可

application.yml文件中的配置

server:
  port: 8080

控制器代码：

@RestController
public class TestController {

    @Value("${server.port}")
    private String serverPort;

    @GetMapping("/test")
    public String test() {
        return "使用 " + serverPort + " 端口的服务";
    }
}

启动两个服务

四、nginx负载均衡配置

在nginx的安装目录下找到nginx.conf文件打开进行相关配置，安装目录不可以有中文，否则不能启动



1.轮询机制的配置

	###定义上游服务器(需要被nginx真实代理访问的服务器) 默认是轮训机制，这个是自己添加进去的
    upstream  backServer{
	    server 127.0.0.1:8080  ;
		server 127.0.0.1:8090  ;
	}

###修改nginx自带server内容即可
    server {
        listen       80;
###这个访问地址就是在本地host配置的域名，当然你也可以使用真实的域名
        server_name  www.testnginx.com;
   
        location / {
             ### 指定上游服务器负载均衡服务器
		    proxy_pass http://backServer;
        }

    }

    启动nginx，在浏览器输入 http://www.testnginx.com/test 在地址栏连续回车或者使用鼠标重新加载就会看到页面上的端口交替变化。实现了轮询策略配置。



2.指定权重 weight

Java服务不用修改，只需要在上游服务器中的配置添加权重即可

###定义上游服务器(需要被nginx真实代理访问的服务器) 默认是轮训机制，这里使用权重配置比例为1:2
     upstream backserver {
    server 127.0.0.1:8080  weight=1;
    server 127.0.0.1:8090  weight=2;
    }

    server {
        listen       80;
        server_name  www.testnginx.com;

   
        location / {
             ### 指定上游服务器负载均衡服务器
		    proxy_pass http://backServer;
        }


    重新启动nginx，在浏览器输入 http://www.testnginx.com/test 在地址栏连续回车或者使用鼠标重新加载就会看到页面上的端口出现一次8080，两次8090。实现了权重策略配置。

3.依据ip分配方式  ip_hash

  Java服务不用修改，只需要在上游服务器中的配置添加ip_hash即可

	###定义上游服务器(需要被nginx真实代理访问的服务器)
		upstream backserver {
			ip_hash;
			server 127.0.0.1:8080;
			server 127.0.0.1:8090;
		}

    server {
        listen       80;
        server_name  www.testnginx.com;

   
        location / {
             ### 指定上游服务器负载均衡服务器
		    proxy_pass http://backServer;
        }

    }

    重新启动nginx，在浏览器输入 http://www.testnginx.com/test 在地址栏连续回车或者使用鼠标重新加载就会看到页面上的端口只会出现一种，更换浏览器请求地址也是不变的。实现了依据IP策略配置。

4、最少连接 least_conn

  Java服务不用修改，只需要在上游服务器中的配置添加least_conn;即可

	###定义上游服务器(需要被nginx真实代理访问的服务器) 
     upstream backserver {
		least_conn;
		server 127.0.0.1:8080  ;
		server 127.0.0.1:8090  ;
    }

    server {
        listen       80;
        server_name  www.testnginx.com;

   
        location / {
             ### 指定上游服务器负载均衡服务器
		    proxy_pass http://backServer;
        }

    }

  由于我的测试没有并发量测试不出来，结果和轮询类似。

五、以上配置可以配合使用

如下：

     upstream backserver {
		least_conn;
		server 127.0.0.1:8080  weight=2;
		server 127.0.0.1:8090  ;
    }

    server {
        listen       80;
        server_name  www.testnginx.com;

   
        location / {
             ### 指定上游服务器负载均衡服务器
		    proxy_pass http://backServer;
        }

    }