熔断器设计模式

public abstract class CircuitBreakerState{    protected CircuitBreakerState(CircuitBreaker circuitBreaker)
    {        this.circuitBreaker = circuitBreaker;
    }    /// <summary>
    /// 调用受保护方法之前处理的操作    /// </summary>    public virtual void ProtectedCodeIsAboutToBeCalled() {        //如果是断开状态，直接返回
        //然后坐等超时转换到半断开状态        if (circuitBreaker.IsOpen)
        {            throw new OpenCircuitException();
        }
    }    /// <summary>
    /// 受熔断器保护的方法调用成功之后的操作    /// </summary>    public virtual void ProtectedCodeHasBeenCalled()
    {
        circuitBreaker.IncreaseSuccessCount();
    }    /// <summary>
    ///受熔断器保护的方法调用发生异常操作后的操作    /// </summary>
    /// <param name="e"></param>    public virtual void ActUponException(Exception e)
    {        //增加失败次数计数器，并且保存错误信息        circuitBreaker.IncreaseFailureCount(e);        //重置连续成功次数        circuitBreaker.ResetConsecutiveSuccessCount();
    }    protected readonly CircuitBreaker circuitBreaker;
}

public class ClosedState : CircuitBreakerState{    public ClosedState(CircuitBreaker circuitBreaker)
        : base(circuitBreaker)
    {        //重置失败计数器        circuitBreaker.ResetFailureCount();
    }    public override void ActUponException(Exception e)
    {        base.ActUponException(e);        //如果失败次数达到阈值，则切换到断开状态        if (circuitBreaker.FailureThresholdReached())
        {
            circuitBreaker.MoveToOpenState();
        }
    }
}

public class OpenState : CircuitBreakerState{    private readonly Timer timer;    public OpenState(CircuitBreaker circuitBreaker)
        : base(circuitBreaker)
    {
        timer = new Timer(circuitBreaker.Timeout.TotalMilliseconds);
        timer.Elapsed += TimeoutHasBeenReached;
        timer.AutoReset = false;
        timer.Start();
    }    //断开超过设定的阈值，自动切换到半断开状态    private void TimeoutHasBeenReached(object sender, ElapsedEventArgs e)
    {
        circuitBreaker.MoveToHalfOpenState();
    }    public override void ProtectedCodeIsAboutToBeCalled()
    {        base.ProtectedCodeIsAboutToBeCalled();        throw new OpenCircuitException();
    }
}

public class HalfOpenState : CircuitBreakerState{    public HalfOpenState(CircuitBreaker circuitBreaker)
        : base(circuitBreaker)
    {        //重置连续成功计数        circuitBreaker.ResetConsecutiveSuccessCount();
    }    public override void ActUponException(Exception e)
    {        base.ActUponException(e);        //只要有失败，立即切换到断开模式        circuitBreaker.MoveToOpenState();
    }    public override void ProtectedCodeHasBeenCalled()
    {        base.ProtectedCodeHasBeenCalled();        //如果连续成功次数达到阈值，切换到闭合状态        if (circuitBreaker.ConsecutiveSuccessThresholdReached())
        {
            circuitBreaker.MoveToClosedState();
        }
    }
}

public class CircuitBreaker{    private readonly object monitor = new object();    private CircuitBreakerState state;    public int FailureCount { get; private set; }    public int ConsecutiveSuccessCount { get; private set; }    public int FailureThreshold { get; private set; }    public int ConsecutiveSuccessThreshold { get; private set; }    public TimeSpan Timeout { get; private set; }    public Exception LastException { get; private set; }    public bool IsClosed
    {        get { return state is ClosedState; }
    }    public bool IsOpen
    {        get { return state is OpenState; }
    }    public bool IsHalfOpen
    {        get { return state is HalfOpenState; }
    }    internal void MoveToClosedState()
    {
        state = new ClosedState(this);
    }    internal void MoveToOpenState()
    {
        state = new OpenState(this);
    }    internal void MoveToHalfOpenState()
    {
        state = new HalfOpenState(this);
    }    internal void IncreaseFailureCount(Exception ex)
    {
        LastException = ex;
        FailureCount++;
    }    internal void ResetFailureCount()
    {
        FailureCount = 0;
    }    internal bool FailureThresholdReached()
    {        return FailureCount >= FailureThreshold;
    }    internal void IncreaseSuccessCount()
    {
        ConsecutiveSuccessCount++;
    }    internal void ResetConsecutiveSuccessCount()
    {
        ConsecutiveSuccessCount = 0;
    }    internal bool ConsecutiveSuccessThresholdReached()
    {        return ConsecutiveSuccessCount >= ConsecutiveSuccessThreshold;
    }}

public CircuitBreaker(int failedthreshold, int consecutiveSuccessThreshold, TimeSpan timeout)
{    if (failedthreshold < 1 || consecutiveSuccessThreshold < 1)
    {        throw new ArgumentOutOfRangeException("threshold", "Threshold should be greater than 0");
    }    if (timeout.TotalMilliseconds < 1)
    {        throw new ArgumentOutOfRangeException("timeout", "Timeout should be greater than 0");
    }

    FailureThreshold = failedthreshold;
    ConsecutiveSuccessThreshold = consecutiveSuccessThreshold;
    Timeout = timeout;
    MoveToClosedState();
}

public void AttemptCall(Action protectedCode)
{    using (TimedLock.Lock(monitor))
    {
        state.ProtectedCodeIsAboutToBeCalled();
    }    try    {
        protectedCode();
    }    catch (Exception e)
    {        using (TimedLock.Lock(monitor))
        {
            state.ActUponException(e);
        }        throw;
    }    using (TimedLock.Lock(monitor))
    {
        state.ProtectedCodeHasBeenCalled();
    }
}

public void Close()
{    using (TimedLock.Lock(monitor))
    {
        MoveToClosedState();
    }
}public void Open()
{    using (TimedLock.Lock(monitor))
    {
        MoveToOpenState();
    }
}

private static void CallXAmountOfTimes(Action codeToCall, int timesToCall)
{    for (int i = 0; i < timesToCall; i++)
    {
        codeToCall();
    }
}

private static void AssertThatExceptionIsThrown<T>(Action code) where T : Exception{    try    {
        code();
    }    catch (T)
    {        return;
    }    Assert.Fail("Expected exception of type {0} was not thrown", typeof(T).FullName);
}

[Test]public void ClosesIfProtectedCodeSucceedsInHalfOpenState()
{    var stub = new Stub(10);    //定义熔断器，失败10次进入断开状态
    //5秒后进入半断开状态
    //在半断开状态下，连续成功15次，进入闭合状态    var circuitBreaker = new CircuitBreaker(10, 15, TimeSpan.FromMilliseconds(5000));    Assert.That(circuitBreaker.IsClosed);    //失败10次调用    CallXAmountOfTimes(() => AssertThatExceptionIsThrown<ApplicationException>(() => circuitBreaker.AttemptCall(stub.DoStuff)), 10);    Assert.AreEqual(10, circuitBreaker.FailureCount);    Assert.That(circuitBreaker.IsOpen);    //等待从Open转到HalfOpen    Thread.Sleep(6000);    Assert.That(circuitBreaker.IsHalfOpen);    //成功调用15次    CallXAmountOfTimes(()=>circuitBreaker.AttemptCall(stub.DoStuff), 15);    Assert.AreEqual(15, circuitBreaker.ConsecutiveSuccessCount);    Assert.AreEqual(0, circuitBreaker.FailureCount);    Assert.That(circuitBreaker.IsClosed);
}