精华内容
下载资源
问答
  • 主要介绍了Java加权负载均衡策略实现过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 加权轮询后端集群每台机器都分配一个权重,权重高得会承担更多的流量,相反权重低的分配的流量也会少,这种策略允许后端集群机器配置差异化java实现import java.util.ArrayList;import java.util.HashMap;import ...

    加权轮询

    后端集群每台机器都分配一个权重,权重高得会承担更多的流量,相反权重低的分配的流量也会少,这种策略允许后端集群机器配置差异化

    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实现

    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...

    负载均衡系列专题

    本节我们来看一下如何实现一负载均衡框架。

    源码

    核心接口定义

    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后面的...

    一、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;
            }
    
        }
    展开全文
  • 一、Zookeeper实现负载均衡原理 分布式微服务中的概念: 生产者、消费者、服务、注册中心、服务治理 dubbo是使用的临时节点。 zk使用的是临时节点来存储,服务的地址的。 负载均衡是在订单服务里面做的。 ...
  • 引言先来看下nginx在web服务器排名上的趋势:存在即合理,那为什么要使用nginx呢?这得看看nginx能帮我们做些什么。首先,nginx能做反向代理【关于反向代理和正向代理此处不做说明...再者,nginx能实现负载均衡,什...
  • HashMap源码解析(负载因子,树化策略,内部hash实现 resize策略) 讲在前面的小知识点: 哈希表(k,v):数组 根据相应的哈希算法计算key,返回值即为value存储的数组下标 哈希算法:f(k)->int即为v需要...
  • 分布式系统中一个非常重要的概念,当访问的服务具有多个实例时,需要根据某种“均衡”的策略决定请求发往哪个节点,这就是所谓的负载均衡, 原理是将数据流量分摊到多个服务器执行,减轻每台服务器的压力,从而提高...
  • 负载均衡和应用交换功能通过各种策略导向到合适的服务器;会话的保持以实现与应用系统完美结合;F5在应用交换技术中的优势:A、截获和检查流量◆BIG-IP 有最强的数据包截获和检查引擎去检查任何数据流量包中的任何.....
  • Nginx实现负载均衡

    2019-06-03 19:44:53
    Nginx实现负载均衡有轮询策略和权重策略两种.实际项目中根据需求,希望新服务器提供更多的服务,所有以权重策略配置为主. 配置前将打包好的部署在三台服务器上 在项目文件夹路径中输入cmd打开控制台: 使用命令java -...
  • 算法实现了多个模型和均衡策略,能通过配置实现随机、轮询、一致hash等。同时也能实现跨机房的相关分配。现已经在多个系统中使用。TAG负载均衡内容现有系统中存在的问题:1.慢连接、瞬时访问...
  • 一、负载均衡策略1、Random LoadBalance,随机(默认)RandomLoadBalance 是加权随机算法的具体实现,可以完全随机,也可以按权重设置随机概率。2、RoundRobin LoadBalance,轮循可以轮询和加权轮询。存在响...
  • 资源介绍Java电商项目负载均衡集群与分布式架构教程2018新品从单服务器到Tomcat集群架构演进Nginx负载均衡策略解析Nginx负载均衡配置及实战Tomcat+Nginx集群环境搭建Redis+Cookie+Jackson+Filter原生实现集群session...
  • Dubbo是一款高性能、轻量级的开源Java RPC框架,它提供了三大核心能力:面向接口的远程方法调用,智能容错和负载均衡,以及服务自动注册和发现。 Dubbo提供了多种负载均衡策略,缺省为random随机调用 随机均衡...
  • 本文适合有 Java 基础知识的人群本文作者:HelloGitHub-秦人HelloGitHub 推出的《讲解开源项目》系列,今天给大家带来一款开源 Java 版可以实现动态服务发现,配置和服务管理平台——Nacos,它是阿里巴巴团队开源...
  • 负载均衡实现方案

    2021-02-04 16:01:38
    负载均衡实现方案 压测工具jmeter ​ Apache JMeter是Apache组织开发的基于Java的压力测试工具。用于对软件做压力测试,它可以用于对服务器、网络或对象模拟繁重的负载来测试它们的强度或分析不同压力类型下的整体...
  • 负责均衡客户端,不是服务器...使用本地负载均衡策略去请求服务 轮询、随机、一致哈希性、加权、哈希 Nginx是c写的,ribbon是java写的,前者性能较好 依赖主要用spring-cloud-starter-netflix-eureka-client ...
  • 1.前言上一篇我们实现了Spring Cloud从nacos server 远端拉取并加载配置。今天我将给广大java开发者介绍nacos的另一个重要功能服务注册与发现。服务注册与发现功能在微服务中服务治理的基础。本篇将对nacos的服务...
  • Dubbo admin作用: 服务治理、日志管理、服务降级、负载均衡、路由策略 权限 Dubbo权重。 服务治理:就是管理集群的地址、监控、容错机制、负载均衡、统计。 DubboAdmin管理平台搭建 使用Dubbo admin管理平台必须...
  • 这一篇理论的东西就不解释了,直接上代码,有兴趣的可以看简书上另一篇文章:数据库分库分表(一)常见分布式主键ID生成策略package util;/*** Twitter-snowflake负载均衡主键算法* 共分成4段:* 1.符号位( 1bit)* 2....
  • 一致性hash通常用在客户端的负载均衡策略,目的就是在变更服务器数量时,能尽量保证命中率。这样就不会造成缓存雪崩的问题。下列代码就是通过模拟正常hash和一致性hash的比对进行。 对于正常的hash而言,当我们存入...
  • 负载均衡调用策略接口 import com.itcast.rpc.client.channel.ProviderService; import java.util.List; /** * 负载均衡调用策略接口 */ public interface ClusterStrategy { /** * 根据规则选取对应的服务 ...
  • 那么工作队列就有两种实现策略:无界队列和有界队列。无界队列不存在饱和的问题,但是其问题是当请求持续高负载的话,任务会无脑的加入工作队列,那么很可能导致内存等资源溢出或者耗尽。而有界队列不会带来高负载...
  • 在linux执行命令: nohup java -jar xxx.jar --server.port=8080 & nohup java -jar xxx.jar --server.port=8081 &...使用nginx进行反向代理,负载均衡策略,提高服务器吞吐量,减轻服务器压力 下载...
  • nginx基础 一、nginx基础与安全体系架构 nginx的作用: 1、nginx做反向代理、代理服务器、静态服务器。 2、nginx作用: 做集群(减轻单台服务器的压力)。... nignx实现方向代理(不暴露真实ip)....
  • 最近开发一了个答题抽奖项目,由于部署项目采用了负载均衡策略,分配奖品时必须使用分布式锁,项目开发完成后记录一下利用redisson实现分布式锁的过程 一、springboot项目整合redisson redisson pom依赖如下 <...
  • 实现一个java远程调用

    千次阅读 2019-06-30 09:14:40
    最花力气的并不是rpc的问题,rpc的方案已经有非常多的方案可以完成了,主要的问题在于通讯机制、负载、选举策略、服务治理等方向,这些方向与本篇文章越扯越远,我在这里只分享如何实现一个java的远程调用。...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 220
精华内容 88
关键字:

java实现负载策略

java 订阅