熔斷器設計模式

轉載自：http://www.cnblogs.com/yangecnu/p/Introduce-Circuit-Breaker-Pattern.html
原作者：yangecnu

如果大家有印象的話，尤其是夏天，如果家裏用電負載過大，比如開了很多家用電器，就會”自動跳閘”，此時電路就會斷開。在以前更古老的一種方式是”保險絲”，當負載過大，或者電路發生故障或異常時，電流會不斷升高，爲防止升高的電流有可能損壞電路中的某些重要器件或貴重器件，燒燬電路甚至造成火災。保險絲會在電流異常升高到一定的高度和熱度的時候，自身熔斷切斷電流，從而起到保護電路安全運行的作用。

同樣，在大型的軟件系統中，如果調用的遠程服務或者資源由於某種原因無法使用時，如果沒有這種過載保護，就會導致請求的資源阻塞在服務器上等待從而耗盡系統或者服務器資源。很多時候剛開始可能只是系統出現了局部的、小規模的故障，然而由於種種原因，故障影響的範圍越來越大，最終導致了全局性的後果。軟件系統中的這種過載保護就是本文將要談到的熔斷器模式(Circuit Breaker)

一問題的產生
在大型的分佈式系統中，通常需要調用或操作遠程的服務或者資源，這些遠程的服務或者資源由於調用者不可以控的原因比如網絡連接緩慢，資源被佔用或者暫時不可用等原因，導致對這些遠程資源的調用失敗。這些錯誤通常在稍後的一段時間內可以恢復正常。

但是，在某些情況下，由於一些無法預知的原因導致結果很難預料，遠程的方法或者資源可能需要很長的一段時間才能修復。這種錯誤嚴重到系統的部分失去響應甚至導致整個服務的完全不可用。在這種情況下，採用不斷地重試可能解決不了問題，相反，應用程序在這個時候應該立即返回並且報告錯誤。

通常，如果一個服務器非常繁忙，那麼系統中的部分失敗可能會導致 “連鎖失效”（cascading failure）。比如，某個操作可能會調用一個遠程的WebService，這個service會設置一個超時的時間，如果響應時間超過了該時間就會拋出一個異常。但是這種策略會導致併發的請求調用同樣的操作會阻塞，一直等到超時時間的到期。這種對請求的阻塞可能會佔用寶貴的系統資源，如內存，線程，數據庫連接等等，最後這些資源就會消耗殆盡，使得其他系統不相關的部分所使用的資源也耗盡從而拖累整個系統。在這種情況下，操作立即返回錯誤而不是等待超時的發生可能是一種更好的選擇。只有當調用服務有可能成功時我們再去嘗試。

二解決方法
熔斷器模式可以防止應用程序不斷地嘗試執行可能會失敗的操作，使得應用程序繼續執行而不用等待修正錯誤，或者浪費CPU時間去等到長時間的超時產生。熔斷器模式也可以使應用程序能夠診斷錯誤是否已經修正，如果已經修正，應用程序會再次嘗試調用操作。

熔斷器模式就像是那些容易導致錯誤的操作的一種代理。這種代理能夠記錄最近調用發生錯誤的次數，然後決定使用允許操作繼續，或者立即返回錯誤。

熔斷器可以使用狀態機來實現，內部模擬以下幾種狀態。

閉合（closed）狀態：
對應用程序的請求能夠直接引起方法的調用。代理類維護了最近調用失敗的次數，如果某次調用失敗，則使失敗次數加1。如果最近失敗次數超過了在給定時間內允許失敗的閾值，則代理類切換到斷開(Open)狀態。此時代理開啓了一個超時時鐘，當該時鐘超過了該時間，則切換到半斷開（Half-Open）狀態。該超時時間的設定是給了系統一次機會來修正導致調用失敗的錯誤。
斷開(Open)狀態：在該狀態下，對應用程序的請求會立即返回錯誤響應。
半斷開（Half-Open）狀態：允許對應用程序的一定數量的請求可以去調用服務。如果這些請求對服務的調用成功，那麼可以認爲之前導致調用失敗的錯誤已經修正，此時熔斷器切換到閉合狀態(並且將錯誤計數器重置)；如果這一定數量的請求有調用失敗的情況，則認爲導致之前調用失敗的問題仍然存在，熔斷器切回到斷開方式，然後開始重置計時器來給系統一定的時間來修正錯誤。半斷開狀態能夠有效防止正在恢復中的服務被突然而來的大量請求再次拖垮。

各個狀態之間的轉換如下圖：

在Close狀態下，錯誤計數器是基於時間的。在特定的時間間隔內會自動重置。這能夠防止由於某次的偶然錯誤導致熔斷器進入斷開狀態。觸發熔斷器進入斷開狀態的失敗閾值只有在特定的時間間隔內，錯誤次數達到指定錯誤次數的閾值纔會產生。在Half-Open狀態中使用的連續成功次數計數器記錄調用的成功次數。當連續調用成功次數達到某個指定值時，切換到閉合狀態，如果某次調用失敗，立即切換到斷開狀態，連續成功調用次數計時器在下次進入半斷開狀態時歸零。

實現熔斷器模式使得系統更加穩定和有彈性，在系統從錯誤中恢復的時候提供穩定性，並且減少了錯誤對系統性能的影響。它通過快速的拒絕那些試圖有可能調用會導致錯誤的服務，而不會去等待操作超時或者永遠不會不返回結果來提高系統的響應事件。如果熔斷器設計模式在每次狀態切換的時候會發出一個事件，這種信息可以用來監控服務的運行狀態，能夠通知管理員在熔斷器切換到斷開狀態時進行處理。

可以對熔斷器模式進行定製以適應一些可能會導致遠程服務失敗的特定場景。比如，可以在熔斷器中對超時時間使用不斷增長的策略。在熔斷器開始進入斷開狀態的時候，可以設置超時時間爲幾秒鐘，然後如果錯誤沒有被解決，然後將該超時時間設置爲幾分鐘，依次類推。在一些情況下，在斷開狀態下我們可以返回一些錯誤的默認值，而不是拋出異常。

三要考慮的因素
在實現熔斷器模式的時候，以下這些因素需可能需要考慮：

異常處理：調用受熔斷器保護的服務的時候，我們必須要處理當服務不可用時的異常情況。這些異常處理通常需要視具體的業務情況而定。比如，如果應用程序只是暫時的功能降級，可能需要切換到其它的可替換的服務上來執行相同的任務或者獲取相同的數據，或者給用戶報告錯誤然後提示他們稍後重試。
異常的類型：請求失敗的原因可能有很多種。一些原因可能會比其它原因更嚴重。比如，請求會失敗可能是由於遠程的服務崩潰，這可能需要花費數分鐘來恢復；也可能是由於服務器暫時負載過重導致超時。熔斷器應該能夠檢查錯誤的類型，從而根據具體的錯誤情況來調整策略。比如，可能需要很多次超時異常纔可以斷定需要切換到斷開狀態，而只需要幾次錯誤提示就可以判斷服務不可用而快速切換到斷開狀態。
日誌：熔斷器應該能夠記錄所有失敗的請求，以及一些可能會嘗試成功的請求，使得的管理員能夠監控使用熔斷器保護的服務的執行情況。
測試服務是否可用：在斷開狀態下，熔斷器可以採用定期的ping遠程的服務或者資源，來判斷是否服務是否恢復，而不是使用計時器來自動切換到半斷開狀態。這種ping操作可以模擬之前那些失敗的請求，或者可以使用通過調用遠程服務提供的檢查服務是否可用的方法來判斷。
手動重置：在系統中對於失敗操作的恢復時間是很難確定的，提供一個手動重置功能能夠使得管理員可以手動的強制將熔斷器切換到閉合狀態。同樣的，如果受熔斷器保護的服務暫時不可用的話，管理員能夠強制的將熔斷器設置爲斷開狀態。
併發問題：相同的熔斷器有可能被大量併發請求同時訪問。熔斷器的實現不應該阻塞併發的請求或者增加每次請求調用的負擔。
資源的差異性：使用單個熔斷器時，一個資源如果有分佈在多個地方就需要小心。比如，一個數據可能存儲在多個磁盤分區上(shard)，某個分區可以正常訪問，而另一個可能存在暫時性的問題。在這種情況下，不同的錯誤響應如果混爲一談，那麼應用程序訪問的這些存在問題的分區的失敗的可能性就會高，而那些被認爲是正常的分區，就有可能被阻塞。
加快熔斷器的熔斷操作:有時候，服務返回的錯誤信息足夠讓熔斷器立即執行熔斷操作並且保持一段時間。比如，如果從一個分佈式資源返回的響應提示負載超重，那麼可以斷定出不建議立即重試，而是應該等待幾分鐘後再重試。（HTTP協議定義了”HTTP
503 Service Unavailable”來表示請求的服務當前不可用，他可以包含其他信息比如，超時等）
重複失敗請求：當熔斷器在斷開狀態的時候，熔斷器可以記錄每一次請求的細節，而不是僅僅返回失敗信息，這樣當遠程服務恢復的時候，可以將這些失敗的請求再重新請求一次。

四使用場景
應該使用該模式來：

防止應用程序直接調用那些很可能會調用失敗的遠程服務或共享資源。不適合的場景
對於應用程序中的直接訪問本地私有資源，比如內存中的數據結構，如果使用熔斷器模式只會增加系統額外開銷。
不適合作爲應用程序中業務邏輯的異常處理替代品

五實現
根據上面的狀態切換圖，我們很容易實現一個基本的熔斷器，只需要在內部維護一個狀態機，並定義好狀態轉移的規則，可以使用State模式來實現。首先，我們定義一個表示狀態轉移操作的抽象類CircuitBreakerState：

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;

}
抽象類中，狀態機CircuitBreaker通過構造函數注入；當發生錯誤時，我們增加錯誤計數器，並且重置連續成功計數器，在增加錯誤計數器操作中，同時也記錄了出錯的異常信息。

然後在分別實現表示熔斷器三個狀態的類。首先實現閉合狀態CloseState：

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();
    }
}

}
在閉合狀態下，如果發生錯誤，並且錯誤次數達到閾值，則狀態機切換到斷開狀態。斷開狀態OpenState的實現如下：

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();
}

}
斷開狀態內部維護一個計數器，如果斷開達到一定的時間，則自動切換到版斷開狀態，並且，在斷開狀態下，如果需要執行操作，則直接拋出異常。

最後半斷開Half-Open狀態實現如下：

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();
    }
}

}
切換到半斷開狀態時，將連續成功調用計數重置爲0，當執行成功的時候，自增改字段，當達到連讀調用成功次數的閾值時，切換到閉合狀態。如果調用失敗，立即切換到斷開模式。

有了以上三種狀態切換之後，我們要實現CircuitBreaker類了:

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;
}

}
在該類中首先：

定義了一些記錄狀態的變量，如FailureCount，ConsecutiveSuccessCount 記錄失敗次數，連續成功次數，以及FailureThreshold，ConsecutiveSuccessThreshold記錄最大調用失敗次數，連續調用成功次數。這些對象對外部來說是隻讀的。
定義了一個 CircuitBreakerState類型的state變量，以表示當前系統的狀態。
定義了一些列獲取當前狀態的方法IsOpen,IsClose,IsHalfOpen,以及表示狀態轉移的方法MoveToOpenState，MoveToClosedState等，這些方法比較簡單，根據名字即可看出用意。
然後，可以通過構造函數將在Close狀態下最大失敗次數，HalfOpen狀態下使用的最大連續成功次數，以及Open狀態下的超時時間通過構造函數傳進來：

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();

}
在初始狀態下，熔斷器切換到閉合狀態。

然後，可以通過AttempCall調用，傳入期望執行的代理方法，該方法的執行受熔斷器保護。這裏使用了鎖來處理併發問題。

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();
}

}
最後，提供Close和Open兩個方法來手動切換當前狀態。

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(Action code) where T : Exception
{
try
{
code();
}
catch (T)
{
return;
}

Assert.Fail("Expected exception of type {0} was not thrown", typeof(T).FullName);

}
然後，使用NUnit，可以建立如下Case：

[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(() => 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);

}
這個Case模擬了熔斷器中狀態的轉換。首先初始化時，熔斷器處於閉合狀態，然後連續10次調用拋出異常，這時熔斷器進去了斷開狀態，然後讓線程等待6秒，此時在第5秒的時候，狀態切換到了半斷開狀態。然後連續15次成功調用，此時狀態又切換到了閉合狀態。

七結論
在應用系統中，我們通常會去調用遠程的服務或者資源(這些服務或資源通常是來自第三方)，對這些遠程服務或者資源的調用通常會導致失敗，或者掛起沒有響應，直到超時的產生。在一些極端情況下，大量的請求會阻塞在對這些異常的遠程服務的調用上，會導致一些關鍵性的系統資源耗盡，從而導致級聯的失敗，從而拖垮整個系統。熔斷器模式在內部採用狀態機的形式，使得對這些可能會導致請求失敗的遠程服務進行了包裝，當遠程服務發生異常時，可以立即對進來的請求返回錯誤響應，並告知系統管理員，將錯誤控制在局部範圍內，從而提高系統的穩定性和可靠性。

本文首先介紹了熔斷器模式使用的場景，能夠解決的問題，以及需要考慮的因素，最後使用代碼展示瞭如何實現一個簡單的熔斷器，並且給出了測試用例，希望這些對您有幫助，尤其是在當您的系統調用了外部的遠程服務或者資源，同時訪問量又很大的情況下對提高系統的穩定性和可靠性有所幫助。

八參考文獻
1. 互聯網巨頭爲什麼會“宕機”, http://edge.iteye.com/blog/1933145

互聯網巨頭爲什麼會“宕機”（二）, http://edge.iteye.com/blog/1936151
Circuit Breaker, http://martinfowler.com/bliki/CircuitBreaker.html
Circuit Breaker Pattern, http://msdn.microsoft.com/en-us/library/dn589784.aspx

熔斷器設計模式

前端使用 Konva 實現可視化設計器（13）- 折線 - 最優路徑應用【思路篇】

scratch社區使用說明

IDE Goland DEBUG報錯（could not launch process: decoding dwarf section info at offset 0x0: too short）

golang中vendor引起的相同類型，但是確提示類型不一樣問題

php pack、unpack、ord 函數使用方法（二進制流接口應用實例）［轉載］

epoll講解

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結