public class RetryRule extends AbstractLoadBalancerRule {
public Server choose(ILoadBalancer lb, Object key) {
long requestTime = System.currentTimeMillis();
long deadline = requestTime + maxRetryMillis;
Server answer = null;
// 调用轮询策略
answer = subRule.choose(key);
// 如果轮询策略没获取到服务器 || 服务器未激活 && 在指定的最大重试时间内
if (((answer == null) || (!answer.isAlive()))
&& (System.currentTimeMillis() < deadline)) {
// 开启守护线程，监视剩余指定的重试时间
InterruptTask task = new InterruptTask(deadline
System.currentTimeMillis());
// 在指定的重试时间范围内，当前线程如没中断，循环调用轮询策略
while (!Thread.interrupted()) {
answer = subRule.choose(key);
if (((answer == null) || (!answer.isAlive()))
&& (System.currentTimeMillis() < deadline)) {
/* pause and retry hoping it’s transient */
Thread.yield();
} else {
break;
}
}
task.cancel();
}
if ((answer == null) || (!answer.isAlive())) {
return null;
} else {
return answer;
}
}
}
加权响应时间 - WeightedResponseTimeRule
=================================
WeightedResponseTimeRule 类继承了轮询策略类 RandomRule
初始化时，启动一个定时器，每隔 30s 根据服务的响应时间分配一次权重，响应时间越长，权重越低，被选择到的概率也越低。响应时间越短，权重越高，实例被选中概率越高。得到权重后，生成随机权重，命中权重比随机权重大的第一个服务实例。
public class WeightedResponseTimeRule extends RoundRobinRule {
// 每隔 30s 统计各服务权重
public static final int DEFAULT_TIMER_INTERVAL = 30 * 1000;
// 记录累计权重
private volatile List accumulatedWeights = new ArrayList();
// 初始化
void initialize(ILoadBalancer lb) {
if (serverWeightTimer != null) {
serverWeightTimer.cancel();
}
serverWeightTimer = new Timer(“NFLoadBalancer-serverWeightTimer-”
name, true);
// 统计各服务权重
serverWeightTimer.schedule(new DynamicServerWeightTask(), 0,
serverWeightTaskTimerInterval);
// do a initial run
ServerWeight sw = new ServerWeight();
sw.maintainWeights();
Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
public void run() {
logger
.info(“Stopping NFLoadBalancer-serverWeightTimer-”
name);
serverWeightTimer.cancel();
}
}));
}
@Override
public Server choose(ILoadBalancer lb, Object key) {
if (lb == null) {
return null;
}
Server server = null;
while (server == null) {
List currentWeights = accumulatedWeights;
// 判断线程是否中断
if (Thread.interrupted()) {
return null;
}
// 获取服务器列表
List allList = lb.getAllServers();
int serverCount = allList.size();
if (serverCount == 0) {
return null;
}
int serverIndex = 0;
// currentWeights.size() - 1 是所有权重的总和
double maxTotalWeight = currentWeights.size() == 0 ? 0 : currentWeights.get(currentWeights.size() - 1);
// 未命中任何服务器就调用轮询策略获取
if (maxTotalWeight < 0.001d || serverCount != currentWeights.size()) {
server = super.choose(getLoadBalancer(), key);
if(server == null) {
return server;
}
} else {
// 从 0 到 所有权重总和之间获取随机数作为随机权重
double randomWeight = random.nextDouble() * maxTotalWeight;
int n = 0;
// 命中权重比随机权重大的第一个服务实例
for (Double d : currentWeights) {
if (d >= randomWeight) {
serverIndex = n;
break;
} else {
n++;
}
}
server = allList.get(serverIndex);
}
if (server == null) {
/* Transient. */
Thread.yield();
continue;
}
if (server.isAlive()) {
return (server);
}
// Next.
server = null;
}
return server;
}
}
// 内部类
class ServerWeight {
public void maintainWeights() {
ILoadBalancer lb = getLoadBalancer();
if (lb == null) {
return;
}
if (!serverWeightAssignmentInProgress.compareAndSet(false, true)) {
return;
}
try {
logger.info(“Weight adjusting job started”);
AbstractLoadBalancer nlb = (AbstractLoadBalancer) lb;
LoadBalancerStats stats = nlb.getLoadBalancerStats();
if (stats == null) {
// no statistics, nothing to do
return;
}
double totalResponseTime = 0;
// 计算出所有服务实例累计的平均响应时间
for (Server server : nlb.getAllServers()) {
ServerStats ss = stats.getSingleServerStat(server);
totalResponseTime += ss.getResponseTimeAvg();
}
// 记录累计权重
Double weightSoFar = 0.0;
// 存放所有服务的权重
List finalWeights = new ArrayList();
for (Server server : nlb.getAllServers()) {
ServerStats ss = stats.getSingleServerStat(server);
// 每个服务权重 = 所有服务的平均响应时间总和 - 当前服务的平均响应时间
// 所以服务的响应时间越大，权重越小，被选中的可能性越小
double weight = totalResponseTime - ss.getResponseTimeAvg();
weightSoFar += weight;
finalWeights.add(weightSoFar);
}
setWeights(finalWeights);
} catch (Exception e) {
logger.error(“Error calculating server weights”, e);
} finally {
serverWeightAssignmentInProgress.set(false);
}
}
}
例如：现在有三个服务实例，平均响应时间分别为：
A：100ms B：200ms C：300ms
则权重分别是：
A：600-100 = 500 B：500+600-200 = 900 C：900+600-300 = 1200
生成的随机数若在 0-500 之间，则命中服务 A，如在 500 - 900 之间，则命中服务 B，如在 900 - 1200，则命中服务 C，如果没有命中任何服务实例，则取轮询策略的结果。
最佳可用策略 - BestAvailableRule
==========================
如未指定负载均衡器，采用轮询策略选取一个服务实例；
如指定了负载均衡器，逐个考察服务实例，过滤掉断路器跳闸状态的实例，从未过滤掉的实例中选择一个并发量最小的实例。如果未命中，则轮询策略选取一个服务实例。
public class BestAvailableRule extends ClientConfigEnabledRoundRobinRule {
@Override
public Server choose(Object key) {
// 未指定负载均衡器，调用轮询策略
if (loadBalancerStats == null) {
return super.choose(key);
}
// 获取所有服务器列表
List serverList = getLoadBalancer().getAllServers();
// 最小并发连接数
int minimalConcurrentConnections = Integer.MAX_VALUE;
long currentTime = System.currentTimeMillis();
Server chosen = null;
// 遍历服务器列表
for (Server server: serverList) {
// 获取服务器统计信息
ServerStats serverStats = loadBalancerStats.getSingleServerStat(server);
// 如果服务器断路器没有发生断路器跳闸，过滤掉断路器跳闸的实例
if (!serverStats.isCircuitBreakerTripped(currentTime)) {
int concurrentConnections = serverStats.getActiveRequestsCount(currentTime);
// 选择并发量最小的实例
if (concurrentConnections < minimalConcurrentConnections) {
minimalConcurrentConnections = concurrentConnections;
chosen = server;
}
}
}
// 如未命中，轮询选取一个实例
if (chosen == null) {
return super.choose(key);
} else {
return chosen;
}
}
}
可用性过滤策略 - AvailabilityFilteringRule
===================================
该策略继承自抽象策略 PredicateBasedRule 类。
通过轮询的方式选取一个服务，如果不匹配过滤条件，则继续轮询10次，如果10次还未命中，就轮询选取一个实例。
过滤条件：断路器故障或者并发请求超过了设置的并发阈值
public class AvailabilityFilteringRule extends PredicateBasedRule {
@Override
public Server choose(Object key) {
int count = 0;
// 轮询策略选一个实例
Server server = roundRobinRule.choose(key);
while (count++ <= 10) {
// 判断是否符合断言条件
if (predicate.apply(new PredicateKey(server))) {
return server;
}
// 不满足断言条件再轮询选择一个实例
server = roundRobinRule.choose(key);
}
// 超过10次还不满足，使用 父类 PredicateBasedRule策略
return super.choose(key);
}
}
看看父类 PredicateBasedRule 的负载策略
public abstract class PredicateBasedRule extends ClientConfigEnabledRoundRobinRule {
@Override
public Server choose(Object key) {
ILoadBalancer lb = getLoadBalancer();
// 根据条件过滤后，采用轮询策略选取实例
Optional server = getPredicate().chooseRoundRobinAfterFiltering(lb.getAllServers(), key);
if (server.isPresent()) {
return server.get();
} else {
return null;
}
}
}
来看看上述中的断言条件是什么，进入到AvailabilityPredicate类查看断言条件
public class AvailabilityPredicate extends AbstractServerPredicate {
@Override
public boolean apply(@Nullable PredicateKey input) {
LoadBalancerStats stats = getLBStats();
if (stats == null) {
return true;
}
return !shouldSkipServer(stats.getSingleServerStat(input.getServer()));
}
private boolean shouldSkipServer(ServerStats stats) {
// 以下两个条件满足其一就过滤实例
// 1、断路器开启并且故障
// 2、实例的并发请求>=阈值
if ((CIRCUIT_BREAKER_FILTERING.get() && stats.isCircuitBreakerTripped())
|| stats.getActiveRequestsCount() >= activeConnectionsLimit.get()) {
return true;
}
return false;
}
}
区域回避策略 - ZoneAvoidanceRule
==========================
继承自 PredicateBasedRule
public class ZoneAvoidanceRule extends PredicateBasedRule {
private static final Random random = new Random();
private CompositePredicate compositePredicate;
public ZoneAvoidanceRule() {
super();
// 两个过滤条件
ZoneAvoidancePredicate zonePredicate = new ZoneAvoidancePredicate(this);
AvailabilityPredicate availabilityPredicate = new AvailabilityPredicate(this);
compositePredicate = createCompositePredicate(zonePredicate, availabilityPredicate);
}
}
两个断言条件
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）
总结
对于面试还是要好好准备的，尤其是有些问题还是很容易挖坑的，例如你为什么离开现在的公司（你当然不应该抱怨现在的公司有哪些不好的地方，更多的应该表明自己想要寻找更好的发展机会，自己的一些现实因素，比如对于我而言是现在应聘的公司离自己的家更近，又或者是自己工作到达了迷茫期，想跳出迷茫期等等）
Java面试精选题、架构实战文档
整理不易，觉得有帮助的朋友可以帮忙点赞分享支持一下小编~
你的支持，我的动力；祝各位前程似锦，offer不断！ 《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！ ]
[外链图片转存中…(img-zWAo5Cqw-1712307663602)]
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）
总结
对于面试还是要好好准备的，尤其是有些问题还是很容易挖坑的，例如你为什么离开现在的公司（你当然不应该抱怨现在的公司有哪些不好的地方，更多的应该表明自己想要寻找更好的发展机会，自己的一些现实因素，比如对于我而言是现在应聘的公司离自己的家更近，又或者是自己工作到达了迷茫期，想跳出迷茫期等等）
[外链图片转存中…(img-xTjByQtl-1712307663602)]
Java面试精选题、架构实战文档
整理不易，觉得有帮助的朋友可以帮忙点赞分享支持一下小编~
你的支持，我的动力；祝各位前程似锦，offer不断！ 《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！
参考阅读
您阅读本篇文章共花了：
发表评论