java轮训算法_java实现轮询和加权轮询

最新推荐文章于 2024-05-05 12:28:08 发布
最新推荐文章于 2024-05-05 12:28:08 发布
阅读量882 收藏 1
点赞数
文章标签： java轮训算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39945789/article/details/111945528
版权

1. 一般轮询算法

服务器类

package com.sosop.roundRobin;

public class Server {

private String ip;

private int weight;

public Server(String ip) {

super();

this.ip = ip;

}

public Server(String ip, int weight) {

this.ip = ip;

this.weight = weight;

}

public String getIp() {

return ip;

}

public void setIp(String ip) {

this.ip = ip;

}

public int getWeight() {

return weight;

}

public void setWeight(int weight) {

this.weight = weight;

}

@Override

public String toString() {

return "Server [ip=" + ip + ", weight=" + weight + "]";

}

}

实现与测试

package com.sosop.roundRobin;

import java.util.ArrayList;

import java.util.List;

import java.util.concurrent.BrokenBarrierException;

import java.util.concurrent.CyclicBarrier;

public class NormalRoundRobin {

private List servers;

private int currentIndex;

private int totalServer;

public NormalRoundRobin() {

servers = new ArrayList<>();

servers.add(new Server("192.168.1.2"));

servers.add(new Server("192.168.1.3"));

servers.add(new Server("192.168.1.4"));

servers.add(new Server("192.168.1.5"));

servers.add(new Server("192.168.1.6"));

servers.add(new Server("192.168.1.7"));

servers.add(new Server("192.168.1.8"));

totalServer = servers.size();

currentIndex = totalServer - 1;

}

// 轮询

public Server round() {

currentIndex = (currentIndex + 1) % totalServer;

return servers.get(currentIndex);

}

public static void main(String[] args) {

final NormalRoundRobin r = new NormalRoundRobin();

// 不带并发的轮询

for (int i = 0; i < 14; i++) {

System.out.println(r.round());

}

System.out.println();

System.out.println("==========================");

System.out.println();

final CyclicBarrier b = new CyclicBarrier(14);

// 带并发的轮询

for (int i = 0; i < 14; i++) {

new Thread(new Runnable() {

@Override

public void run() {

try {

b.await();

System.out.println(Thread.currentThread().getName() + " " + r.round());

} catch (InterruptedException | BrokenBarrierException e) {

e.printStackTrace();

}

}

}, "thread" + i).start();

}

}

}

结果：

Server [ip=192.168.1.2, weight=0]

Server [ip=192.168.1.3, weight=0]

Server [ip=192.168.1.4, weight=0]

Server [ip=192.168.1.5, weight=0]

Server [ip=192.168.1.6, weight=0]

Server [ip=192.168.1.7, weight=0]

Server [ip=192.168.1.8, weight=0]

Server [ip=192.168.1.2, weight=0]

Server [ip=192.168.1.3, weight=0]

Server [ip=192.168.1.4, weight=0]

Server [ip=192.168.1.5, weight=0]

Server [ip=192.168.1.6, weight=0]

Server [ip=192.168.1.7, weight=0]

Server [ip=192.168.1.8, weight=0]

==========================

thread13 Server [ip=192.168.1.2, weight=0]

thread4 Server [ip=192.168.1.6, weight=0]

thread3 Server [ip=192.168.1.5, weight=0]

thread1 Server [ip=192.168.1.3, weight=0]

thread12 Server [ip=192.168.1.7, weight=0]

thread0 Server [ip=192.168.1.2, weight=0]

thread2 Server [ip=192.168.1.4, weight=0]

thread10 Server [ip=192.168.1.6, weight=0]

thread11 Server [ip=192.168.1.5, weight=0]

thread8 Server [ip=192.168.1.3, weight=0]

thread9 Server [ip=192.168.1.4, weight=0]

thread7 Server [ip=192.168.1.2, weight=0]

thread6 Server [ip=192.168.1.8, weight=0]

thread5 Server [ip=192.168.1.7, weight=0]

2.加权轮询

package com.sosop.roundRobin;

import java.math.BigInteger;

import java.util.ArrayList;

import java.util.List;

import java.util.concurrent.BrokenBarrierException;

import java.util.concurrent.CyclicBarrier;

public class WeightRoundRobin {

private List servers;

private int currentIndex;

private int totalServer;

private int currentWeight;

private int maxWeight;

private int gcdWeight;

public WeightRoundRobin() {

servers = new ArrayList<>();

servers.add(new Server("192.168.1.2", 5));

servers.add(new Server("192.168.1.3", 10));

servers.add(new Server("192.168.1.4", 15));

servers.add(new Server("192.168.1.5", 100));

servers.add(new Server("192.168.1.6", 5));

servers.add(new Server("192.168.1.7", 20));

servers.add(new Server("192.168.1.8", 30));

totalServer = servers.size();

currentIndex = totalServer - 1;

maxWeight = maxWeight();

gcdWeight = serverGcd();

}

public Server round() {

while (true) {

currentIndex = (currentIndex + 1) % totalServer;

if (currentIndex == 0) {

currentWeight = currentWeight - gcdWeight;

if (currentWeight <= 0) {

currentWeight = maxWeight;

if(currentWeight == 0) {

return null;

}

}

}

if(servers.get(currentIndex).getWeight() >= currentWeight) {

return servers.get(currentIndex);

}

}

}

/**

* 返回所有服务器的权重的最大公约数

*

* @return

*/

private int serverGcd() {

int comDivisor = 0;

for (int i = 0; i < totalServer - 1; i++) {

if (comDivisor == 0) {

comDivisor = gcd(servers.get(i).getWeight(), servers.get(i + 1).getWeight());

} else {

comDivisor = gcd(comDivisor, servers.get(i + 1).getWeight());

}

}

return comDivisor;

}

/**

* 获得服务器中的最大权重

*

* @return

*/

private int maxWeight() {

int max = servers.get(0).getWeight();

int tmp;

for (int i = 1; i < totalServer; i++) {

tmp = servers.get(i).getWeight();

if (max < tmp) {

max = tmp;

}

}

return max;

}

/**

* 求两个数的最大公约数 4和6最大公约数是2

*

* @param num1

* @param num2

* @return

*/

private int gcd(int num1, int num2) {

BigInteger i1 = new BigInteger(String.valueOf(num1));

BigInteger i2 = new BigInteger(String.valueOf(num2));

return i1.gcd(i2).intValue();

}

public static void main(String[] args) {

final WeightRoundRobin wr = new WeightRoundRobin();

// 非并发情况

for (int i = 0; i < 100; i++) {

System.out.println(wr.round());

}

System.out.println();

System.out.println("==========");

System.out.println();

final CyclicBarrier b = new CyclicBarrier(30);

// 并发情况

for (int i = 0; i < 30; i++) {

new Thread(new Runnable() {

@Override

public void run() {

try {

b.await();

System.out.println(Thread.currentThread().getName() + " " + wr.round());

} catch (InterruptedException | BrokenBarrierException e) {

e.printStackTrace();

}

}

}, "thread" + i).start();

}

}

}

结果：

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.8, weight=30]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.8, weight=30]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.7, weight=20]

Server [ip=192.168.1.8, weight=30]

Server [ip=192.168.1.4, weight=15]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.7, weight=20]

Server [ip=192.168.1.8, weight=30]

Server [ip=192.168.1.3, weight=10]

Server [ip=192.168.1.4, weight=15]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.7, weight=20]

Server [ip=192.168.1.8, weight=30]

Server [ip=192.168.1.2, weight=5]

Server [ip=192.168.1.3, weight=10]

Server [ip=192.168.1.4, weight=15]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.6, weight=5]

Server [ip=192.168.1.7, weight=20]

Server [ip=192.168.1.8, weight=30]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.8, weight=30]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.8, weight=30]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.7, weight=20]

Server [ip=192.168.1.8, weight=30]

Server [ip=192.168.1.4, weight=15]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.7, weight=20]

Server [ip=192.168.1.8, weight=30]

Server [ip=192.168.1.3, weight=10]

Server [ip=192.168.1.4, weight=15]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.7, weight=20]

Server [ip=192.168.1.8, weight=30]

Server [ip=192.168.1.2, weight=5]

Server [ip=192.168.1.3, weight=10]

Server [ip=192.168.1.4, weight=15]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.6, weight=5]

Server [ip=192.168.1.7, weight=20]

Server [ip=192.168.1.8, weight=30]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.8, weight=30]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.8, weight=30]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.7, weight=20]

Server [ip=192.168.1.8, weight=30]

Server [ip=192.168.1.4, weight=15]

Server [ip=192.168.1.5, weight=100]

Server [ip=192.168.1.7, weight=20]

Server [ip=192.168.1.8, weight=30]

Server [ip=192.168.1.3, weight=10]

==========

thread0 Server [ip=192.168.1.5, weight=100]

thread3 Server [ip=192.168.1.2, weight=5]

thread7 Server [ip=192.168.1.6, weight=5]

thread10 Server [ip=192.168.1.5, weight=100]

thread12 Server [ip=192.168.1.5, weight=100]

thread15 Server [ip=192.168.1.5, weight=100]

thread18 Server [ip=192.168.1.5, weight=100]

thread2 Server [ip=192.168.1.8, weight=30]

thread29 Server [ip=192.168.1.5, weight=100]

thread1 Server [ip=192.168.1.7, weight=20]

thread27 Server [ip=192.168.1.8, weight=30]

thread26 Server [ip=192.168.1.5, weight=100]

thread25 Server [ip=192.168.1.8, weight=30]

thread24 Server [ip=192.168.1.5, weight=100]

thread23 Server [ip=192.168.1.5, weight=100]

thread22 Server [ip=192.168.1.5, weight=100]

thread21 Server [ip=192.168.1.5, weight=100]

thread20 Server [ip=192.168.1.5, weight=100]

thread19 Server [ip=192.168.1.5, weight=100]

thread17 Server [ip=192.168.1.5, weight=100]

thread16 Server [ip=192.168.1.5, weight=100]

thread14 Server [ip=192.168.1.5, weight=100]

thread13 Server [ip=192.168.1.5, weight=100]

thread11 Server [ip=192.168.1.5, weight=100]

thread9 Server [ip=192.168.1.8, weight=30]

thread8 Server [ip=192.168.1.7, weight=20]

thread6 Server [ip=192.168.1.5, weight=100]

thread5 Server [ip=192.168.1.4, weight=15]

thread4 Server [ip=192.168.1.3, weight=10]

thread28 Server [ip=192.168.1.5, weight=100]

weixin_39945789
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java轮训算法_loadbalance轮询算法 java实现
weixin_35849560的博客
12-24 640
/*** * * Copyright JasonInternational* All rights reserved.* Created on 2018年5月16日 下午8:33:15* Created by Jason* * */package cn.ucaner.component.loadbalance;import java.util.ArrayList;import j...
java实现加权轮询_负载均衡--加权轮询算法（Weight Round）
weixin_29774037的博客
02-27 815
加权轮询算法：不同的后端服务器，在机器的配置和当前系统的负载方面，可能并不相同。因此，它们的抗压能力也不相同。给配置高、负载低的机器配置更高的权重，让其处理更多的请求；给配置低、负载高的机器分配较低的权重，降低系统负载。加权轮询算法能很好地处理这一问题，并将请求顺序地按照权重分配到后端服务器。一、算法描述假设有 N 台服务器 S = {S0, S1, S2, …, Sn}，默认权重为 W = {W...
java实现轮询和加权轮询
sosop's Blog
12-08 4404
1. 一般轮询算法 服务器类 package com.sosop.roundRobin; public class Server { private String ip; private int weight; public Server(String ip) { super(); this.ip = ip; } public Server(...
2024年Java最全加权轮询算法(wrr)，这个考点，概率有一点点高哦，2024年Java开发实战
最新发布
a19815156的博客
05-05 677
2021年的金三银四一眨眼就到了，对于很多人来说是跳槽的好机会，大厂面试远没有我们想的那么困难，摆好心态，做好准备，你也可以的。另外，面试中遇到不会的问题不妨尝试讲讲自己的思路，因为有些问题不是考察我们的编程能力，而是逻辑思维表达能力；最后平时要进行自我分析与评价，做好职业规划，不断摸索，提高自己的编程能力和抽象思维能力。BAT面试经验实战系列：Spring全家桶+Redis等其他相关的电子书：源码+调优面试真题：本文已被。
Java实现负载均衡算法--轮询和加权轮询
hekliu的博客
05-07 2011
Java实现负载均衡算法，简单轮询算法，加权轮询算法
java常见轮询算法
shuixiou1的博客
03-10 8976
轮询算法 轮询算法就是通过一个算法，对提供的一组列表进行计算，按照一定规则取出列表中的元素，常见的有顺序模式、随机模式、加权模式，加权平滑模式。 定义轮询算法的接口： /** * 轮询算法接口 */ public interface Balance<T> { T chooseOne(List<T> list); } 1、随机模式轮询 public class RandomBalance<T> implements Balance<T&gt
简单的负载均衡算法
坚持住啊
12-06 552
https://www.cnblogs.com/xrq730/p/5154340.html 什么是负载均衡 负载均衡，英文名称为Load Balance，指由多台服务器以对称的方式组成一个服务器集合，每台服务器都具有等价的地位，都可以单独对外提供服务而无须其他服务器的辅助。通过某种负载分担技术，将外部发送来的请求均匀分配到对称结构中的某一台服务器上，而接收到请求的服务器独立地回应客户的请求。负载均衡能够平均分配客户请求到服务器阵列，借此提供快速获取重要数据，解决大量并发访问服务问题，这种集群技术可以用最
java轮训算法_权重轮询调度算法(WeightedRound-RobinScheduling)-Java实现2
weixin_28820113的博客
12-24 591
1. 一般轮询算法服务器类Java代码 packagecom.sosop.roundRobin;publicclassServer{privateStringip;privateintweight;publicServer(Stringip){super();this.ip=ip;}publicServer(Stringip,intweight){thi...
jinchengdiaodu.rar_jinchengdiaodu_visual c_算法_轮询算法
09-24
本资料包“jinchengdiaodu.rar_jinchengdiaodu_visual c_算法_轮询算法”聚焦于两种常见的进程调度算法——先进先出（FIFO）算法和轮询（Round Robin）算法，并使用Visual C++编程环境进行了模拟实现。下面将详细...
TIA博途SCL语言_MODBUS轮询算法_FB库文件.rar
11-24
本资源"MODBUSPOLL轮询"显然是一个关于使用SCL语言在TIA博途中实现MODBUS协议轮询算法的FB（Function Block）库文件。轮询是通信系统中的一种数据采集方式，其中主设备（如上位机）依次询问各个从设备，获取它们的...
C#实现Nginx平滑加权轮询算法
08-27
C#实现Nginx平滑加权轮询算法是指使用C#语言实现Nginx的平滑加权轮询算法，平滑加权轮询算法是一种常用的负载均衡算法，旨在解决多台服务器之间的流量分配问题。下面将详细介绍C#实现Nginx平滑加权轮询算法的知识点...
一个轮询的java案例
08-08
一架飞机快要掉了，上面有 20 个人，但是只有 3 包降落伞。于是 20 个人凑成一圈，每数到第 7 个，就将他踢下去。 * 最后三包降落伞将落在哪几个人手里？
c# 实现轮询算法实例代码
09-01
总结起来，这个C#实例展示了如何利用轮询算法和缓存机制实现按概率展示页面元素的功能。通过对`m_snIntervalSecond`数组的调整，可以灵活地适应不同的业务需求，改变显示的概率分布。同时，通过缓存管理，确保了在多...
ADS1256-master.zip_1256_ADS1256_ADS1256实现轮询_ads
09-24
综合以上信息，我们可以看到ADS1256-master.zip是一个关于ADS1256 ADC的开发资源包，提供了在不同编程环境下实现ADS1256轮询读取功能的代码和文档。对于需要使用ADS1256的工程师来说，这个资源包将大大简化他们的...
java轮训算法_基于java的负载均衡算法解析及源码分享
weixin_36221082的博客
12-24 112
负载：就是后端系统的承载能力。比如同等条件下，一个1核cpu-1G内存的机器的承载能力一般会比8核cpu-8G内存的机器要差；相同配置下，一个cpu利用率为80%的机器比30%的承载能力一般要差等等。均衡：保证后端请求的平衡。比如：在同等情况下，分配到多台机器的请求要相当；有些情况下，同一用户尽可能分配到同一台机器等等。负载均衡的算法实际上就是解决跨系统调用的时候，在考虑后端机器承载情况的前提下，...
Round-Robin负载均衡算法及其实现原理
Galdys的专栏
07-22 1595
毫无疑问，随着互联网、移动网络接入成本的降低，互联网正在日益深入地走入我们的生活，越来越成为人们获取信息的高效平台，ICP行业也顺势呈现出强劲的成长趋势，成为互联网迅猛发展形势下最大的受益者，也直接促成了从web1.0到web2.0以及社区、博客、视频等一系列互联网时代的更迭和运
java 实现长轮询(LongPolling)
qq_18478183的博客
10-04 4618
长轮询java代码实现，观察者模式，门面模式
两种轮询平均分配的算法
LMC技术人生专栏
11-03 1612
1 第二种简单轮询算法 1 定义一个变量保存索引值，然后每赋值一次， 就加1 用索引取值， 这样的话必须 是list才能取到里面的第几个 int f = 0; for (int j = 0; j < ziNode.size(); j++) { if (f >= maps.size()) { ...
websocket后台轮训
05-11
WebSocket 是一种基于 TCP 的协议，它实现了浏览器与服务器全双工通信，使得数据可以实时地在客户端和服务器之间进行传输。 与传统的 HTTP 请求-响应模式不同，WebSocket 建立了一条持久连接，服务器可以随时主动向客户端推送数据，而不需要客户端发送请求。这种实时性和高效性使得 WebSocket 在实时通信、在线协作、游戏互动等领域得到广泛应用。 WebSocket 基于事件驱动和回调函数机制，可以通过 JavaScript 的 WebSocket API 在浏览器中进行调用。在后台，可以使用 WebSocket 相关的库来开发 WebSocket 服务器，常见的有 Node.js 的 ws、Java 的 Netty 等。 轮询是一种比较繁琐的实现方式，它需要客户端不断地向服务器发送请求，服务器在接收到请求后返回数据，客户端再进行处理和显示。这种方式效率低下，会增加服务器的负担，同时也会造成网络流量的浪费。 相比之下，WebSocket 的实时性更好，且不需要客户端不断地发送请求，减轻了服务器的负担和网络流量的压力。因此，WebSocket 是一种更为高效、实时和可靠的实现方式。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值