服务器雪崩的应对策略之----熔断机制

熔断机制(Circuit Breaker)是一种保护系统稳定性的重要手段。它的主要目的是防止系统在依赖的服务出现问题时,继续发送请求,从而保护系统免受进一步的影响。熔断机制通过监控请求的成功和失败率,在检测到故障率超过预设阈值时,自动切换到熔断状态,停止对故障服务的请求。熔断状态一段时间后,再尝试恢复服务的调用。

常见的熔断机制

熔断机制的三种状态

  1. Closed(闭合状态)

    • 正常状态下,所有请求都会被发送到依赖服务。
    • 监控请求的成功和失败情况。
  2. Open(断开状态)

    • 当故障率超过阈值时,熔断器进入断开状态。
    • 此时,所有请求都会立即失败或返回备用方案,而不会发送到依赖服务。
  3. Half-Open(半开状态)

    • 在断开状态保持一段时间后,熔断器尝试恢复部分请求。
    • 如果部分请求成功,则恢复到闭合状态;如果仍然失败,则回到断开状态。

示例代码

下面的示例代码展示了一个简单的熔断机制实现:

cpp 复制代码
#include <iostream>
#include <chrono>
#include <thread>
#include <mutex>

enum class CircuitBreakerState 
{
    Closed,
    Open,
    HalfOpen
};

class CircuitBreaker 
{
public:
    CircuitBreaker(int failure_threshold, int recovery_timeout)
        : state(CircuitBreakerState::Closed),
          failure_count(0),
          failure_threshold(failure_threshold),
          recovery_timeout(recovery_timeout) {}

    bool allow_request() 
    {
        std::lock_guard<std::mutex> lock(mutex);
        auto now = std::chrono::steady_clock::now();

        if (state == CircuitBreakerState::Open) 
        {
            if (std::chrono::duration_cast<std::chrono::milliseconds>(now - last_failure_time).count() > recovery_timeout) 
            {
                state = CircuitBreakerState::HalfOpen;
                return true;  // Allow a limited number of requests to test recovery
            } 
            else 
            {
                return false;
            }
        }

        return true;
    }

    void record_success() 
    {
        std::lock_guard<std::mutex> lock(mutex);
        failure_count = 0;
        state = CircuitBreakerState::Closed;
    }

    void record_failure() 
    {
        std::lock_guard<std::mutex> lock(mutex);
        failure_count++;
        if (failure_count >= failure_threshold) 
        {
            state = CircuitBreakerState::Open;
            last_failure_time = std::chrono::steady_clock::now();
        }
    }

private:
    CircuitBreakerState state;
    int failure_count;
    int failure_threshold;
    int recovery_timeout;  // in milliseconds
    std::chrono::steady_clock::time_point last_failure_time;
    std::mutex mutex;
};

bool mock_service_call() 
{
    static int counter = 0;
    counter++;
    // Simulate a service that fails 50% of the time
    return counter % 2 == 0;
}

int main() 
{
    CircuitBreaker breaker(3, 5000);  // Allow 3 failures before opening circuit, 5 seconds recovery timeout

    for (int i = 0; i < 20; ++i) 
    {
        if (breaker.allow_request()) 
        {
            if (mock_service_call()) 
            {
                std::cout << "Request " << i << " succeeded\n";
                breaker.record_success();
            } 
            else 
            {
                std::cout << "Request " << i << " failed\n";
                breaker.record_failure();
            }
        } 
        else 
        {
            std::cout << "Request " << i << " blocked by circuit breaker\n";
        }

        std::this_thread::sleep_for(std::chrono::milliseconds(500));  // Simulate time between requests
    }

    return 0;
}

代码解读

  1. CircuitBreaker类:封装熔断器的状态管理逻辑。

    • allow_request():决定是否允许请求通过熔断器。
    • record_success():记录成功的请求,重置失败计数,并将状态恢复为闭合状态。
    • record_failure():记录失败的请求,增加失败计数,并在失败计数达到阈值时将状态设置为断开状态。
  2. mock_service_call():模拟依赖服务的请求。这里简单地模拟了一个服务,它有50%的概率失败。

  3. main函数:模拟一系列请求,并展示熔断机制如何工作。

结论

熔断机制是一种有效的保护系统的方法,尤其是在依赖外部服务时。通过合理的熔断配置,可以避免系统因为外部服务故障而陷入崩溃状态,从而提升系统的稳定性和可靠性。

相关推荐
霁月风3 分钟前
设计模式——观察者模式
c++·观察者模式·设计模式
橘色的喵3 分钟前
C++编程:避免因编译优化引发的多线程死锁问题
c++·多线程·memory·死锁·内存屏障·内存栅栏·memory barrier
荒Huang4 分钟前
Linux挖矿病毒(kswapd0进程使cpu爆满)
linux·运维·服务器
何曾参静谧39 分钟前
「C/C++」C/C++ 之 变量作用域详解
c语言·开发语言·c++
九河云40 分钟前
如何选择适合的AWS EC2实例类型
服务器·云计算·aws
AI街潜水的八角1 小时前
基于C++的决策树C4.5机器学习算法(不调包)
c++·算法·决策树·机器学习
JSU_曾是此间年少1 小时前
数据结构——线性表与链表
数据结构·c++·算法
其乐无涯2 小时前
服务器技术(一)--Linux基础入门
linux·运维·服务器
写bug的小屁孩2 小时前
前后端交互接口(三)
运维·服务器·数据库·windows·用户界面·qt6.3
斑布斑布2 小时前
【linux学习2】linux基本命令行操作总结
linux·运维·服务器·学习