基於.net的分佈式系統限流組件
在互聯網應用中，流量洪峯是常有的事情。在應對流量洪峯時，通用的處理模式通常有排隊、限流，這樣能夠很是直接有效的保護系統，防止系統被打爆。另外，經過限流技術手段，可讓整個系統的運行更加平穩。今天要與你們分享一下限流算法和C#版本的組件。算法
1、令牌桶算法：網絡
令牌桶算法的基本過程以下：ui
- 假如用戶配置的平均發送速率爲r，則每隔1/r秒速率將一個令牌被加入到桶中；
- 假設桶最多能夠存發b個令牌。當桶中的令牌達到上限後，丟棄令牌。
- 當一個有請求到達時，首先去令牌桶獲取令牌，可以取到，則處理這個請求
- 若是桶中沒有令牌，那麼請求排隊或者丟棄
工做過程包括3個階段：產生令牌、消耗令牌和判斷數據包是否經過。其中涉及到2個參數：令牌產生的速率和令牌桶的大小，這個過程的具體工做以下。this
- 產生令牌：週期性的以固定速率向令牌桶中增長令牌，桶中的令牌不斷增多。若是桶中令牌數已到達上限，則丟棄多餘令牌。
- 消費 令牌：業務程序根據具體業務狀況消耗桶中的令牌。消費一次，令牌桶令牌減小一個。
- 判斷是否經過：判斷是否已有令牌桶是否存在有效令牌，當桶中的令牌數量能夠知足需求時，則繼續業務處理，不然將掛起業務，等待令牌。
下面是C#的一個實現方式spa
class TokenBucketLimitingService: ILimitingService
{
private LimitedQueue<object> limitedQueue = null;
private CancellationTokenSource cancelToken;
private Task task = null;
private int maxTPS;
private int limitSize;
private object lckObj = new object();
public TokenBucketLimitingService(int maxTPS, int limitSize)
{
this.limitSize = limitSize;
this.maxTPS = maxTPS;線程if (this.limitSize <= 0)
this.limitSize = 100;
if(this.maxTPS <=0)
this.maxTPS = 1;3dlimitedQueue = new LimitedQueue<object>(limitSize);
for (int i = 0; i < limitSize; i++)
{
limitedQueue.Enqueue(new object());
}
cancelToken = new CancellationTokenSource();
task = Task.Factory.StartNew(new Action(TokenProcess), cancelToken.Token);
}對象/// <summary>
/// 定時消息令牌
/// </summary>
private void TokenProcess()
{
int sleep = 1000 / maxTPS;
if (sleep == 0)
sleep = 1;blogDateTime start = DateTime.Now;
while (cancelToken.Token.IsCancellationRequested ==false)
{
try
{
lock (lckObj)
{
limitedQueue.Enqueue(new object());
}
}
catch
{
}
finally
{
if (DateTime.Now - start < TimeSpan.FromMilliseconds(sleep))
{
int newSleep = sleep - (int)(DateTime.Now - start).TotalMilliseconds;
if (newSleep > 1)
Thread.Sleep(newSleep - 1); //作一下時間上的補償
}
start = DateTime.Now;
}
}
}資源public void Dispose()
{
cancelToken.Cancel();
}/// <summary>
/// 請求令牌
/// </summary>
/// <returns>true：獲取成功，false：獲取失敗</returns>
public bool Request()
{
if (limitedQueue.Count <= 0)
return false;
lock (lckObj)
{
if (limitedQueue.Count <= 0)
return false;object data = limitedQueue.Dequeue();
if (data == null)
return false;
}return true;
}
}
public interface ILimitingService:IDisposable
{
/// <summary>
/// 申請流量處理
/// </summary>
/// <returns>true：獲取成功，false：獲取失敗</returns>
bool Request();
}
public class LimitingFactory
{
/// <summary>
/// 建立限流服務對象
/// </summary>
/// <param name="limitingType">限流模型</param>
/// <param name="maxQPS">最大QPS</param>
/// <param name="limitSize">最大可用票據數</param>
public static ILimitingService Build(LimitingType limitingType = LimitingType.TokenBucket, int maxQPS = 100, int limitSize = 100)
{
switch (limitingType)
{
case LimitingType.TokenBucket:
default:
return new TokenBucketLimitingService(maxQPS, limitSize);
case LimitingType.LeakageBucket:
return new LeakageBucketLimitingService(maxQPS, limitSize);
}
}
}
/// <summary>
/// 限流模式
/// </summary>
public enum LimitingType
{
TokenBucket,//令牌桶模式
LeakageBucket//漏桶模式
}
public class LimitedQueue<T> : Queue<T>
{
private int limit = 0;
public const string QueueFulled = "TTP-StreamLimiting-1001";public int Limit
{
get { return limit; }
set { limit = value; }
}public LimitedQueue()
: this(0)
{ }public LimitedQueue(int limit)
: base(limit)
{
this.Limit = limit;
}public new bool Enqueue(T item)
{
if (limit > 0 && this.Count >= this.Limit)
{
return false;
}
base.Enqueue(item);
return true;
}
}
調用方法：
var service = LimitingFactory.Build(LimitingType.TokenBucket, 500, 200);
while (true)
{
var result = service.Request();
//若是返回true，說明能夠進行業務處理，不然須要繼續等待
if (result)
{
//業務處理......
}
else
Thread.Sleep(1);
}
2、漏桶算法
聲明一個固定容量的桶，每接受到一個請求向桶中添加一個令牌，當令牌桶達到上線後請求丟棄或等待，具體算法以下：
- 建立一個固定容量的漏桶，請求到達時向漏桶添加一個令牌
- 若是請求添加令牌不成功，請求丟棄或等待
- 另外一個線程以固定的速率消費桶裏的令牌
工做過程也包括3個階段：產生令牌、消耗令牌和判斷數據包是否經過。其中涉及到2個參數：令牌自動消費的速率和令牌桶的大小，個過程的具體工做以下。
- 產生令牌：業務程序根據具體業務狀況申請令牌。申請一次，令牌桶令牌加一。若是桶中令牌數已到達上限，則掛起業務後等待令牌。
- 消費令牌：週期性的以固定速率消費令牌桶中令牌，桶中的令牌不斷較少。
- 判斷是否經過：判斷是否已有令牌桶是否存在有效令牌，當桶中的令牌數量能夠知足需求時，則繼續業務處理，不然將掛起業務，等待令牌。
C#的一個實現方式：
class LeakageBucketLimitingService: ILimitingService
{
private LimitedQueue<object> limitedQueue = null;
private CancellationTokenSource cancelToken;
private Task task = null;
private int maxTPS;
private int limitSize;
private object lckObj = new object();
public LeakageBucketLimitingService(int maxTPS, int limitSize)
{
this.limitSize = limitSize;
this.maxTPS = maxTPS;if (this.limitSize <= 0)
this.limitSize = 100;
if (this.maxTPS <= 0)
this.maxTPS = 1;limitedQueue = new LimitedQueue<object>(limitSize);
cancelToken = new CancellationTokenSource();
task = Task.Factory.StartNew(new Action(TokenProcess), cancelToken.Token);
}private void TokenProcess()
{
int sleep = 1000 / maxTPS;
if (sleep == 0)
sleep = 1;DateTime start = DateTime.Now;
while (cancelToken.Token.IsCancellationRequested == false)
{
try
{if (limitedQueue.Count > 0)
{
lock (lckObj)
{
if (limitedQueue.Count > 0)
limitedQueue.Dequeue();
}
}
}
catch
{
}
finally
{
if (DateTime.Now - start < TimeSpan.FromMilliseconds(sleep))
{
int newSleep = sleep - (int)(DateTime.Now - start).TotalMilliseconds;
if (newSleep > 1)
Thread.Sleep(newSleep - 1); //作一下時間上的補償
}
start = DateTime.Now;
}
}
}public void Dispose()
{
cancelToken.Cancel();
}public bool Request()
{
if (limitedQueue.Count >= limitSize)
return false;
lock (lckObj)
{
if (limitedQueue.Count >= limitSize)
return false;return limitedQueue.Enqueue(new object());
}
}
}
調用方法：
var service = LimitingFactory.Build(LimitingType.LeakageBucket, 500, 200);
while (true)
{
var result = service.Request();
//若是返回true，說明能夠進行業務處理，不然須要繼續等待
if (result)
{
//業務處理......
}
else
Thread.Sleep(1);
}
兩類限流算法雖然很是類似，可是仍是有些區別的，供你們參考！
- 漏桶算法可以強行限制數據的傳輸速率。在某些狀況下，漏桶算法不可以有效地使用網絡資源。由於漏桶的漏出速率是固定的。
- 令牌桶算法可以在限制數據的平均傳輸速率的同時還容許某種程度的突發傳輸.
- 1. 基於.net的分佈式系統限流組件
- 2. 基於.net的分佈式系統限流組件（限流算法：令牌算法和漏斗算法）
- 3. 基於Redis的分佈式限流系統的設計
- 4. 基於分佈式環境下限流系統的設計
- 5. 基於Nginx的分佈式限流
- 6. 分佈式系統限流策略（一）
- 7. 分佈式系統架構--限流
- 8. 基於系統負載的動態限流組件 dynamic-limiter
- 9. 分佈式限流組件-基於Redis的註解支持的Ratelimiter
- 10. 主流的分佈式文件系統
- 更多相關文章...
- • 系統定義的TypeHandler - MyBatis教程
- • C# Windows 文件系統的操作 - C#教程
- • Docker容器實戰(七) - 容器眼光下的文件系統
- • ☆基於Java Instrument的Agent實現
-
每一个你不满意的现在，都有一个你没有努力的曾经。