架构设计 | 线上防雪崩利器—熔断器设计原理与实现

最新推荐文章于 2024-08-04 20:53:18 发布
最新推荐文章于 2024-08-04 20:53:18 发布
阅读量1.5k 收藏 4
点赞数 2
分类专栏： 架构设计 文章标签： 熔断器 雪崩 架构设计 状态模式

上周六，我负责的业务在凌晨00-04点的支付全部失败了。

结果一查，MD，晚上银行维护，下游支付系统没有挂维护公告，在此期间一直请求维护中的银行，当然所有返回就是失败了，有种欲哭无泪的感觉，锅让业务来背。

为了杜绝在此出现这种大面积批量的支付失败情况发生，保障系统的健壮性。我需要个在集中性异常的时候可以终止请求，当服务恢复，恢复请求。

我想了一些方式，最后，觉得熔断器比较适合干这种事情。

状态模式

在状态模式中，我们创建表示各种状态的对象和一个行为随着状态对象改变而改变的 context 对象。

我们以一个开关为例：

package com.lpf.熔断器;

public class Main {
	public static void main(String[] args) {
		Context context = new Context();
		context.state = new CloseState();

		context.switchState();
		context.switchState();
		context.switchState();
		context.switchState();
		context.switchState();
	}
}

/**
 * 状态上下文
 */
class Context {
	public State state;

	void switchState() {
		state.switchState(this);
	}
}

/**
 * 状态的抽象
 */
interface State {
	void switchState(Context context);
}

/**
 * 开状态
 **/
class OpenState implements State {

	public void switchState(Context context) {
		System.out.println("当前状态：开");
		context.state = new CloseState();
	}
}

/**
 * 关状态
 **/
class CloseState implements State {

	public void switchState(Context context) {
		System.out.println("当前状态：关");
		context.state = new OpenState();
	}
}

在每一种状态下，context不必关心每一种状态下的行为。交给每一种状态自己处理。

熔断器基本原理

熔断器是当依赖的服务已经出现故障时，为了保证自身服务的正常运行不再访问依赖的服务，防止雪崩效应。
在这里插入图片描述

熔断器本身就是一个状态机：

  • 关闭状态：熔断器的初始化状态，该状态下允许请求通过。当失败超过阀值，转入打开状态；
  • 打开状态：熔断状态，该状态下不允许请求通过，当进入该状态经过一段时间，进入半开状态；
  • 半开状态：在半开状态期间，允许部分请求通过，在半开期间，观察失败状态是否超过阀值。如果没有超过进入关闭状态，如果超过了进入打开状态。如此往复。

之前，查了一些资料，网上所有的资料几乎都是针对Hystrix的。这个只是针对分布式系统的接口请求，并不能运用于我们的系统中，因此这种情况下，根据原理自己实现了一个基本的分布式熔断器，数值与计数器存放在redis中，因为redis的操作客户端不一样，我就以本地熔断器为例，讲解熔断器实现。

希望我的文章能对于理解熔断器，以及需要熔断器的人有所帮助。

简单的本地熔断器实现

源码：https://gitee.com/liupeifeng3514/test_demo/tree/master/src/main/java/com/lpf/熔断器

一个基本的本地熔断器。
在这里插入图片描述

对外暴露接口
熔断器对外暴露接口
/**
 * 熔断器接口
 */
public interface CircuitBreaker {
    /**
     * 重置熔断器
     */
    void reset();

    /**
     * 是否允许通过熔断器
     */
    boolean canPassCheck();

    /**
     * 统计失败次数
     */
    void countFailNum();
}
熔断器状态对外暴露接口
/**
 * 熔断器状态
 */
public interface CBState {
    /**
     * 获取当前状态名称
     */
    String getStateName();

    /**
     * 检查以及校验当前状态是否需要扭转
     */
    void checkAndSwitchState(AbstractCircuitBreaker cb);

    /**
     * 是否允许通过熔断器
     */
    boolean canPassCheck(AbstractCircuitBreaker cb);

    /**
     * 统计失败次数
     */
    void countFailNum(AbstractCircuitBreaker cb);
}
三种状态
关闭状态
import com.lpf.熔断器.cb.AbstractCircuitBreaker;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * 熔断器-关闭状态
 */
public class CloseCBState implements CBState {

    /**
     * 进入当前状态的初始化时间
     */
    private long stateTime = System.currentTimeMillis();

    /**
     * 关闭状态，失败计数器，以及失败计数器初始化时间
     */
    private AtomicInteger failNum = new AtomicInteger(0);
    private long failNumClearTime = System.currentTimeMillis();

    public String getStateName() {
        // 获取当前状态名称
        return this.getClass().getSimpleName();
    }

    public void checkAndSwitchState(AbstractCircuitBreaker cb) {
        // 阀值判断，如果失败到达阀值，切换状态到打开状态
        long maxFailNum = Long.valueOf(cb.thresholdFailRateForClose.split("/")[0]);
        if (failNum.get() >= maxFailNum) {
            cb.setState(new OpenCBState());
        }
    }

    public boolean canPassCheck(AbstractCircuitBreaker cb) {
        // 关闭状态，请求都应该允许通过
        return true;
    }

    public void countFailNum(AbstractCircuitBreaker cb) {
        // 检查计数器是否过期了，否则重新计数
        long period = Long.valueOf(cb.thresholdFailRateForClose.split("/")[1]) * 1000;
        long now = System.currentTimeMillis();
        if (failNumClearTime + period <= now) {
            failNum.set(0);
        }
        // 失败计数
        failNum.incrementAndGet();

        // 检查是否切换状态
        checkAndSwitchState(cb);
    }
}
打开状态
import com.lpf.熔断器.cb.AbstractCircuitBreaker;

/**
 * 熔断器-打开状态
 */
public class OpenCBState implements CBState {
	/**
	 * 进入当前状态的初始化时间
	 */
	private long stateTime = System.currentTimeMillis();

	public String getStateName() {
		// 获取当前状态名称
		return this.getClass().getSimpleName();
	}

	public void checkAndSwitchState(AbstractCircuitBreaker cb) {
		// 打开状态，检查等待时间是否已到，如果到了就切换到半开状态
		long now = System.currentTimeMillis();
		long idleTime = cb.thresholdIdleTimeForOpen * 1000L;
		if (stateTime + idleTime <= now) {
			cb.setState(new HalfOpenCBState());
		}
	}

	public boolean canPassCheck(AbstractCircuitBreaker cb) {
		// 检测状态
		checkAndSwitchState(cb);
		return false;
	}

	public void countFailNum(AbstractCircuitBreaker cb) {
		// nothing
	}
}
半开状态
import com.lpf.熔断器.cb.AbstractCircuitBreaker;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * 熔断器-半开状态
 */
public class HalfOpenCBState implements CBState {

	/**
	 * 进入当前状态的初始化时间
	 */
	private long stateTime = System.currentTimeMillis();

	/**
	 * 半开状态，失败计数器
	 */
	private AtomicInteger failNum = new AtomicInteger(0);

	/**
	 * 半开状态，允许通过的计数器
	 */
	private AtomicInteger passNum = new AtomicInteger(0);

	public String getStateName() {
		// 获取当前状态名称
		return this.getClass().getSimpleName();
	}

	public void checkAndSwitchState(AbstractCircuitBreaker cb) {
		// 判断半开时间是否结束
		long idleTime = Long.valueOf(cb.thresholdPassRateForHalfOpen.split("/")[1]) * 1000L;
		long now = System.currentTimeMillis();
		if (stateTime + idleTime <= now) {
			// 如果半开状态已结束，失败次数是否超过了阀值
			int maxFailNum = cb.thresholdFailNumForHalfOpen;
			if (failNum.get() >= maxFailNum) {
				// 失败超过阀值，认为服务没有恢复，重新进入熔断打开状态
				cb.setState(new OpenCBState());
			} else {
				// 没超过，认为服务恢复，进入熔断关闭状态
				cb.setState(new CloseCBState());
			}
		}
	}

	public boolean canPassCheck(AbstractCircuitBreaker cb) {
		// 检查是否切换状态
		checkAndSwitchState(cb);

		// 超过了阀值，不再放量
		int maxPassNum = Integer.valueOf(cb.thresholdPassRateForHalfOpen.split("/")[0]);
		if (passNum.get() > maxPassNum) {
			return false;
		}
		// 检测是否超过了阀值
		if (passNum.incrementAndGet() <= maxPassNum) {
			return true;
		}
		return false;
	}

	public void countFailNum(AbstractCircuitBreaker cb) {
		// 失败计数
		failNum.incrementAndGet();

		// 检查是否切换状态
		checkAndSwitchState(cb);
	}
}
熔断器
抽象熔断器
import com.lpf.熔断器.state.CBState;
import com.lpf.熔断器.state.CloseCBState;

/**
 * 基础熔断器
 */
public abstract class AbstractCircuitBreaker implements CircuitBreaker {
	/**
	 * 熔断器当前状态
	 */
	private volatile CBState state = new CloseCBState();

	/**
	 * 在熔断器关闭的情况下，在多少秒内失败多少次进入，熔断打开状态（默认10分钟内，失败10次进入打开状态）
	 */
	public String thresholdFailRateForClose = "10/600";

	/**
	 * 在熔断器打开的情况下，熔断多少秒进入半开状态，（默认熔断30分钟）
	 */
	public int thresholdIdleTimeForOpen = 1800;

	/**
	 * 在熔断器半开的情况下, 在多少秒内放多少次请求，去试探(默认10分钟内，放10次请求)
	 */
	public String thresholdPassRateForHalfOpen = "10/600";

	/**
	 * 在熔断器半开的情况下, 试探期间，如果有超过多少次失败的，重新进入熔断打开状态，否者进入熔断关闭状态。
	 */
	public int thresholdFailNumForHalfOpen = 1;

	public CBState getState() {
		return state;
	}

	public void setState(CBState state) {
		// 当前状态不能切换为当前状态
		CBState currentState = getState();
		if (currentState.getStateName().equals(state.getStateName())) {
			return;
		}

		// 多线程环境加锁
		synchronized (this) {
			// 二次判断
			currentState = getState();
			if (currentState.getStateName().equals(state.getStateName())) {
				return;
			}

			// 更新状态
			this.state = state;
			System.out.println("熔断器状态转移：" + currentState.getStateName() + "->" + state.getStateName());
		}
	}
}
本地熔断器
import com.lpf.熔断器.state.CloseCBState;

/**
 * 本地熔断器(把它当成了工厂了)
 */
public class LocalCircuitBreaker extends AbstractCircuitBreaker {
	
	public LocalCircuitBreaker(String failRateForClose, int idleTimeForOpen, String passRateForHalfOpen, int failNumForHalfOpen) {
		this.thresholdFailRateForClose = failRateForClose;
		this.thresholdIdleTimeForOpen = idleTimeForOpen;
		this.thresholdPassRateForHalfOpen = passRateForHalfOpen;
		this.thresholdFailNumForHalfOpen = failNumForHalfOpen;
	}

	public void reset() {
		this.setState(new CloseCBState());
	}

	public boolean canPassCheck() {
		return getState().canPassCheck(this);
	}

	public void countFailNum() {
		getState().countFailNum(this);
	}
}
测试例子
import com.lpf.熔断器.cb.CircuitBreaker;
import com.lpf.熔断器.cb.LocalCircuitBreaker;

import java.util.Random;
import java.util.concurrent.CountDownLatch;


public class App {

	public static void main(String[] args) throws InterruptedException {
		final int maxNum = 200;
		final CountDownLatch countDownLatch = new CountDownLatch(maxNum);

		final CircuitBreaker circuitBreaker = new LocalCircuitBreaker("5/20", 10, "5/10", 2);

		for (int i = 0; i < maxNum; i++) {
			new Thread(new Runnable() {
				public void run() {
					try {
						// 模拟随机请求
						Thread.sleep(new Random().nextInt(20) * 1000);
						// 过熔断器
						if (circuitBreaker.canPassCheck()) {
							// do something
							System.out.println("正常业务逻辑操作");

							// 模拟后期的服务恢复状态
							if (countDownLatch.getCount() >= maxNum / 2) {
								// 模拟随机失败
								if (new Random().nextInt(2) == 1) {
									throw new Exception("mock error");
								}
							}
						} else {
							System.out.println("拦截业务逻辑操作");
						}
					} catch (Exception e) {
						System.out.println("业务执行失败了");
						// 熔断器计数器
						circuitBreaker.countFailNum();
					}
					countDownLatch.countDown();
				}
			}).start();

			// 模拟随机请求
			Thread.sleep(new Random().nextInt(5) * 100);
		}

		countDownLatch.await();
		System.out.println("end");
	}
}
结果
正常业务逻辑操作
正常业务逻辑操作
正常业务逻辑操作
业务执行失败了
正常业务逻辑操作
正常业务逻辑操作
业务执行失败了
正常业务逻辑操作
正常业务逻辑操作
业务执行失败了
正常业务逻辑操作
正常业务逻辑操作
正常业务逻辑操作
正常业务逻辑操作
正常业务逻辑操作
业务执行失败了
正常业务逻辑操作
正常业务逻辑操作
正常业务逻辑操作
业务执行失败了
熔断器状态转移：CloseCBState->OpenCBState
拦截业务逻辑操作
拦截业务逻辑操作
拦截业务逻辑操作
......
拦截业务逻辑操作
拦截业务逻辑操作
熔断器状态转移：OpenCBState->HalfOpenCBState
拦截业务逻辑操作
正常业务逻辑操作
业务执行失败了
正常业务逻辑操作
正常业务逻辑操作
正常业务逻辑操作
业务执行失败了
正常业务逻辑操作
业务执行失败了
拦截业务逻辑操作
拦截业务逻辑操作
......
拦截业务逻辑操作
熔断器状态转移：HalfOpenCBState->OpenCBState
拦截业务逻辑操作
拦截业务逻辑操作
......
拦截业务逻辑操作
熔断器状态转移：OpenCBState->HalfOpenCBState
拦截业务逻辑操作
正常业务逻辑操作
正常业务逻辑操作
正常业务逻辑操作
正常业务逻辑操作
正常业务逻辑操作
拦截业务逻辑操作
拦截业务逻辑操作
......
拦截业务逻辑操作
熔断器状态转移：HalfOpenCBState->CloseCBState
拦截业务逻辑操作
正常业务逻辑操作
正常业务逻辑操作
......
正常业务逻辑操作
end




文章来源：https://www.jianshu.com/p/fad81d945e2d

参考文章：

挖坑埋你
关注
专栏目录
一文讲透自适应熔断的原理和实现
我心飞翔
11-18 1564
为什么需要熔断 微服务集群中，每个应用基本都会依赖一定数量的外部服务。有可能随时都会遇到网络连接缓慢，超时，依赖服务过载，服务不可用的情况,在高并发场景下如果此时调用方不做任何处理，继续持续请求故障服务的话很容易引起整个微服务集群雪崩。 比如高并发场景的用户订单服务，一般需要依赖一下服务： 商品服务 账户服务 库存服务 假如此时 账户服务 过载，订单服务持续请求账户服务只能被动的等待账户服务报错或者请求超时，进而导致订单请求被大量堆积，这些无效请求依然会占用系统资源：cp
Spring技术内幕：深入解析Spring架构与设计原理(第1部分)
10-25
Spring技术内幕 深入解析Spring架构与设计原理1(完整清晰版)，一共两部分,这是第一部分 《Spring技术内幕：深入解析Spring架构与设计原理》是Spring领域的问鼎之作，由业界拥有10余年开发经验的资深Java专家亲自...
微服务高可用之熔断器实现原理与 Golang 实践
kevin_tech的博客，微信搜「网管叨bi叨」
12-30 531
I.内容提要在微服务架构中，经常会碰到服务超时或通讯失败的问题，由于服务间层层依赖，很可能由于某个服务出现问题，不合理的重试和超时设置，导致问题层层传递引发雪崩现象，而限流和熔断是解决这...
Java中的服务降级与熔断机制设计与实现：提升系统可靠性的技术
最新发布
微赚淘客系统开发者博客
08-04 796
在分布式系统中，服务之间的依赖关系复杂，当某个服务出现故障或响应变慢时，可能会导致整个系统的崩溃。通过本文的介绍，我们了解了服务降级与熔断机制在提升系统可靠性方面的重要性，并学习了如何在Java中使用Hystrix实现这些功能。用户服务依赖订单服务，当订单服务不可用时，用户服务需要提供降级响应。熔断机制是一种保护系统的方法，当某个服务的调用失败次数达到一定阈值时，自动断开对该服务的调用，防止故障蔓延。服务降级与熔断机制在实际应用中往往是结合使用的，通过合理配置，可以有效提升系统的稳定性和可靠性。
分布式熔断、限流与服务保护：深入 Hystrix 原理及使用
热门推荐
刘本龙的专栏
03-29 1万+
原文链接，也是本人写的：http://gitbook.cn/books/5a61644f6a16de239e22e55d/index.html 我的hystrix几篇文章目录： 分布式熔断、限流与服务保护：深入 Hystrix 原理及使用 RxJava 驯服数据流之时间平移 Hystrix 1.5 滑动窗口实现原理总结 目录 集成到springboot 集成到springMV...
设计模式--状态模式（分布式中间件熔断器Java实现）
weixin_34303897的博客
01-06 201
  　　最近在做分布式服务熔断，因为要实现一个熔断器状态机，所以想到状态模式。状态模式是当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类。状态模式主要解决的是当控制一个对象状态的条件表达式过于复杂时的情况。把状态的判断逻辑转移到表示不同状态的一系列类中，可以把复杂的判断逻辑简化。   先举个简单的例子，以红绿灯模型，说明状态模式是怎么一回事：   通常情况下我们是这...
线上防雪崩利器——熔断器设计原理与实现
Franco的博客
09-26 327
上周六，我负责的业务在凌晨00-04点的支付全部失败了。 结果一查，MD，晚上银行维护，下游支付系统没有挂维护公告，在此期间一直请求维护中的银行，当然所有返回就是失败了，有种欲哭无泪的感觉，锅让业务来背。 为了杜绝在此出现这种大面积批量的支付失败情况发生，保障系统的健壮性。我需要个在集中性异常的时候可以终止请求，当服务恢复，恢复请求。 我想了一些方式，最后，觉得熔断器比较适合干这种事情。 ...
Spring技术内幕：深入解析Spring架构与设计原理(第2部分)
10-25
Spring技术内幕：深入解析Spring架构与设计原理(第2部分) 《Spring技术内幕：深入解析Spring架构与设计原理》是Spring领域的问鼎之作，由业界拥有10余年开发经验的资深Java专家亲自执笔!Java开发者社区和Spring...
Spring技术内幕：深入解析Spring架构与设计原理 2/2
11-15
　国内第一本基于spring3．0的著作，从源代码的角度对spring的内核和各个主要功能模块的架构、设计和实现原理进行了深入剖析。你不仅能从木书中参透spring框架的优秀架构和设计思想，而且还能从spring优雅的实现源码...
Spring技术内幕：深入解析Spring架构与设计原理(第一部分)
10-25
Spring技术内幕 深入解析Spring架构与设计原理1(完整清晰版)，一共两部分,这是第一部分 《Spring技术内幕：深入解析Spring架构与设计原理》是Spring领域的问鼎之作，由业界拥有10余年开发经验的资深Java专家亲自...
详解spring cloud分布式关于熔断器
08-27
主要介绍了详解spring cloud分布式关于熔断器，详细的介绍了什么是熔断器和使用，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
window redis 初始化
培训班的蜗牛
08-31 355
参考 https://blog.csdn.net/qian_qian_123/article/details/85161320 下载：
熔断原理
m0_51684972的博客
03-21 388
熔断原理 熔断器，也叫断路器，其英文单词为：Circuit Breaker 熔断状态机3个状态： Closed：关闭状态，所有请求都正常访问。 Open：打开状态，所有请求都会被降级。Hystix会对请求情况计数，当一定时间内失败请求百分比达到阈值，则触发熔断，断路器会完全打开。默认失败比例的阈值是50%，请求次数最少不低于20次。 Half Open：半开状态，open状态不是永久的，打开后会进入休眠时间（默认是5S）。随后断路器会自动进入半开状态。此时会释放部分请求通过，若这些请求都是健康的，则会完全
防雪崩利器：熔断器 Hystrix 的原理与使用
chuixue24的博客
04-28 239
前言 分布式系统中经常会出现某个基础服务不可用造成整个系统不可用的情况, 这种现象被称为服务雪崩效应. 为了应对服务雪崩, 一种常见的做法是手动服务降级. 而Hystrix的出现,给我们提供了另一种选择. 服务雪崩效应的定义 服务雪崩效应是一种因服务提供者的不可用导致服务调用者的不可用,并将不可用逐渐放大的过程.如果所示: 上图中, A为服务提供者, B为A的服务调用者, C和D是B的服务调用者. 当A的不可用,引起B的不可用,并将不可用逐渐放大C和D时, 服务雪崩就形成了. ...
什么是微服务中的熔断器设计模式？
小技术君
05-15 368
在本文中，我将解释什么是熔断器设计模式以及它解决了什么问题。我们将仔细研究熔断器设计模式，并探讨如何使用Spring Cloud Netflix Hystrix在Java中实现它。到本文结束时，您将更好地了解如何使用熔断器设计模式提高微服务架构的弹性。熔断器设计模式是一种在分布式系统中使用的设计模式，用于在一个或多个服务失败时防止级联故障。熔断器设计模式的工作原理是在服务失败时提供回退机制，而不是...
高频设计利器：EM仿真器的建模应用与求解器选择
"通过EM仿真器对声/电设计进行建模" 在电子工程领域，特别是高频和微波设计中，EM（Electromagnetic）仿真器是不可或缺的工具。它们允许工程师在实际制造设备之前，对声学、机械和电气组件进行虚拟测试，从而避免...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值