.Net 如何模拟会话级别的信号量，对http接口调用频率进行限定(有demo)

当今，因为种种因素，你必须对一个央或措施开展频率上之访限制。
据，
你对外提供了一个API接口，注册用户每秒钟最多可调用100糟糕，非注册用户每秒钟最多足调用10涂鸦。
按照，
有一个颇吃服务器资源的计，在一如既往时刻不可知跨越10私家调用这个措施，否则服务器满载。
仍， 有局部奇异的页面，访客并无能够屡屡之造访还是发言。
以， 秒杀活动等展开。
论
，防范DDOS，当及一定频率后调用脚本iis服务器ip黑名单，防火墙黑名单。
万一齐种的比喻，也就是说，如何从一个断面的角度对调用的计开展频率上的克。而针对性效率限制，服务器层面都生极致直白的化解措施，现在自己说之虽是代码层面上的频率管控。

正文为闹点儿个示范，一个是基于单机环境之兑现，第二只则是冲分布式的Redis实现。

因为率先单API接口需求吗条例，先说生单机环境下的贯彻。
遵惯性思维，我们当然会想到缓存的逾期策略这种办法，但是严格来讲就是HttpRuntime.Cache而言，通过缓存的过策略来对要进行频率的出现控制是不合适的。
　　HttpRuntime.Cache
是应用程序级别之Asp.Net的缓存技术，通过这个技能好说明多只缓存对象，可以吗每个对象设置过时，当过时刻到达晚该缓存对象就是会见没有(也即是当您看该对象的当儿也Null)

　　为什么如此说啊？比如针对某个方法（方法名：GetUserList）我们若开展1秒钟最多10不善的限制，现在咱们尽管新建一个int型的Cache对象，然后设置1秒钟后过消失。那么以访问GetUserList方法前，我们便先判断这Cache对象的价是否超越10，如果超过10即不执行GetUserList方法，如果低于10尽管允许实施。每当访问该对象的时节要未在或者过就新建，这样循环，则该目标永远不可能逾10。

1   if ((int)HttpRuntime.Cache["GetUserListNum"] > 10) //大于10请求失败
2   {
3      Console.WriteLine("禁止请求");
4   }
5   else
6   {
7      HttpRuntime.Cache["GetUserListNum"] = (int)HttpRuntime.Cache["GetUserListNum"] + 1; //否则该缓存对象的值+1
8      Console.WriteLine("允许请求");
9   }

诸如此类的思考以及实现相对来说非常简单，但是依据这样的一个模型设定，那么就会现出这种状况：

设齐图，每个点代表一样不行走访请求，我在0秒的时节
新建了一个名字啊GetUserListNum的缓存对象。
在0~0.5秒中
我访问了3涂鸦，在0.5~1秒内，我们看了7不成。此时，该目标消失，然后我们跟着访问，该对象重置为0.
　　　　　　　　　　　　　 
 在第1~1.5秒里，还是看了7软，在第1.5秒~2秒之内做客了3浅。

冲这种简易缓存过期策略的范，在当时2秒钟内，我们虽然平均每秒钟都看了10不好，满足是规定，但是如果我们于中取一个以内段，0.5秒~1.5秒内，也是1秒钟，但是可实实在在的造访了14涂鸦！远远超了我们装的
1秒钟最多看10不成的 限制。

这就是说什么样科学的来解决地方的题材吗？我们可由此模拟对话级别的信号量即时等同招数，这吗便是咱今天之主题了。
　　　什么是信号量?仅就因代码而言，  static
SemaphoreSlim semaphoreSlim = new SemaphoreSlim(5); 
它的意就是象征于多线程情况下，在其余一样整日，只能以5个线程去访问。

4容器4线程模型

本，在贯彻代码的事先我们事先规划一个型。

　　假设我们出一个用户A的管道，这个管道里装在用户A的要，比如用户A在一如既往秒钟发出了10破呼吁，那么每一个请求过来，管道里之要素都见面多一个。但是我们设定是管道最多只能容10个因素，而且每个元素的存活期为1秒，1秒后虽说该因素消失。那么这样设计吧，无论是速率还是多少之突进，都见面发出管道长度的限量。这样一来，无论由哪一个时节点还是时间距离出发，这个管道都能满足我们的频率限制需求。

假设这里的管道，就必须跟会话Id来对号入座了。每当发生新会话进来的时段就是很成一个新管道。这个会话id根据自己场景所定，可以是sessionId，可以是ip，也足以是token。

这就是说既是管道是碰头说话级别的，我们定得用一个容器，来装这些管道。现在，我们坐IP来命名会话管道，并把具有的管道还装在一个器皿被，如图

若果据悉刚才底设定，我们尚需对容器内的各国条管道的素进行处理，把过的吃删除掉，为这个，还待单独为该容器开辟有一个线程来吧各个条管道展开元素的清理。而当管道的因素呢0时，我们即便到底掉该管道，以便节省容器空间。

自然，由于用户量基本上，一个容器内或者有上万独管道，这个上偏偏用一个容器来装来清理，在效率达明显是不够的。这个时节，我们就算得对容器进行横向扩张了。

　　比如，我们得以根据Cpu核心数自动生成对应之数据之容器，然后根据一个算法，对IP来拓展导流。我当下cpu是4只逻辑核心，就不行成了4个容器，每当用户访问的时刻，都见面冠经过一个算法，这个算法会对IP进行处理，如192.168.1.11~192.168.1.13以此Ip段进第一个容器，xxx~xxx进第二只容器，依次类推，相应的，也尽管闹了4个线程去分别处理4个容器被的管道。

那么，最终便形成了咱们的4容器4线程模型了。

现行，着眼于编码实现：

　　首先我们用一个能够承载这些器皿的载体，这个载体类似于连接池的定义，可以根据部分索要自动生成适应数量的器皿，如果生特殊要求的言辞，还可以以容器上切出一个器皿管理的给，在线程上切出一个线程管理之照以便为实时监察及调度。如果的确使做这样一个网，那么
容器的调度 和 线程的调度功能
是必备的，而本Demo则是得了首要功能，像容器与线程在代码中本身啊绝非退开来，算法为是直接写好的，实际设计中，对算法的规划尚是可怜重大之，还有多线程模型中，怎样上锁才会于效率最大化为是根本的。

万一这里为了案例之直观就直接写很成4只容器。

public static List<Container> ContainerList = new List<Container>(); //容器载体
static Factory()
{
     for (int i = 0; i < 4; i++)
     {
        ContainerList.Add(new Container(i));  //遍历4次  生成4个容器
     }
     foreach (var item in ContainerList)
     {
        item.Run();    //开启线程
     }
}

而今，我们若 有编号也 0 到 40 这样的 41只用户。那么这个导流算法
我吧就算一直写深，编号0至9底用户
将他们之呼吁被丢转到第一单容器，编号10~19底用户
放到第二独容器，编号20~29推广至第三单容器，编号30~40底用户放第四只容器。

那么这个代码就是这般的：

 static Container GetContainer(int userId, out int i) //获取容器的算法
 {
     if (0 <= userId && userId < 10)    //编号0至9的用户  返回第一个容器  依次类推
     {
          i = 0;
          return ContainerList[0];
     }
     if (10 <= userId && userId < 20)
     {
          i = 1;
          return ContainerList[1];
     }
     if (20 <= userId && userId < 30)
     {
          i = 2;
          return ContainerList[2];
      }
      i = 3;
      return ContainerList[3];
  }

当我们的对话请求经过算法的导流之后，都不能不调用一个方式，用于辨别管道数量。如果管道数量就超过10，则呼吁失败，否则成功

  public static void Add(int userId)
  {
       if (GetContainer(userId, out int i).Add(userId))
            Console.WriteLine("容器" + i + " 用户" + userId + "  发起请求");
       else
            Console.WriteLine("容器" + i + " 用户" + userId + "  被拦截");
  }

连着下去便容器Container的代码了。

此处，对容器的选型用线程安全之ConcurrentDictionary类。
　　线程安全：当多个线程同时读写及一个共享元素的时候，就会现出数错乱，迭代报错等安全问提
　　ConcurrentDictionary：除了GetOrAdd方法而慎用外，是.Net4.0揽为解决Dictionary线程安全而出之初类型
　　ReaderWriterLockSlim：较ReaderWriterLock优化的读写锁，多单线程同时做客读锁
或  一个线程访问写锁

private ReaderWriterLockSlim obj = new ReaderWriterLockSlim();  //在每个容器中申明一个读写锁
public ConcurrentDictionary<string, ConcurrentList<DateTime>> dic = new ConcurrentDictionary<string, ConcurrentList<DateTime>>(); //创建该容器 dic

下一场当你向容器上加同条管道被之数额是经此法：

 public bool Add(int userId)
 {
     obj.EnterReadLock();//挂读锁，允许多个线程同时写入该方法
     try
     {
         ConcurrentList<DateTime> dtList = dic.GetOrAdd(userId.ToString(),t=>{ new ConcurrentList<DateTime>()}); //如果不存在就新建 ConcurrentList
         return dtList.CounterAdd(10, DateTime.Now); //管道容量10，当临界管道容量后 返回false
     }
     finally
     {
         obj.ExitReadLock();
     }
 }

 这里，为了当背后的线程遍历删除ConcurrentList的管道的时光保证ConcurrentList的安全性，所以这里设加读锁。

 而ConcurrentList，因为.Net没有出List集合类的线程安全(此间我说明下：之所以不用ConcurrentBag是因只要保证count和add的一致性，这里补充一下)，所以自己新建了一个蝉联给List<T>的平安种，在此间
封装了3独需要采用的办法。

public class ConcurrentList<T> : List<T>
{
    private object obj = new object();

    public bool CounterAdd(int num, T value)
    {
        lock (obj)
        {
            if (base.Count >= num)
                return false;
            else
                base.Add(value);
            return true;
        }
    }
    public new bool Remove(T value)
    {
        lock (obj)
        {
            base.Remove(value);
            return true;
        }
    }
    public new T[] ToArray() 
    {
        lock (obj)
        {
            return base.ToArray();
        }
    }
}

最后便是线程的运转方式：

 public void Run()
 {
     ThreadPool.QueueUserWorkItem(c =>
     {
         while (true)
         {
             if (dic.Count > 0)
             {
                 foreach (var item in dic.ToArray())
                 {
                     ConcurrentList<DateTime> list = item.Value;
                     foreach (DateTime dt in list.ToArray())   
                     {
                         if (DateTime.Now.AddSeconds(-3) > dt)
                         {
                             list.Remove(dt);
                             Console.WriteLine("容器" + seat + " 已删除用户" + item.Key + "管道中的一条数据");
                         }
                     }
                     if (list.Count == 0)
                     {
                         obj.EnterWriteLock();
                         try
                         {
                             if (list.Count == 0)
                             {
                                 if (dic.TryRemove(item.Key, out ConcurrentList<DateTime> i))
                                 { Console.WriteLine("容器" + seat + " 已清除用户" + item.Key + "的List管道"); }
                             }
                         }
                         finally
                         {
                             obj.ExitWriteLock();
                         }
                     }
                 }

             }
             else
             {
                 Thread.Sleep(100);
             }
         }
     }
   );
 }

终极，是法力图，一个是根据控制台的，还一个凡是依据Signalr的。

分布式下Redis

点介绍了同等种频率限制的范，分布式与单机相比，无非就是是载体不同，我们设把这个容器的载体从程序上移植出来，来弄成一个独门的劳务或者直接借用Redis也是实用之。

这边虽介绍分布式情况下，Redis的落实。

不等于Asp.Net的多线程模型，大概因为Redis的各种类型的素非常粒度的操作造成各种加锁之纷繁，所以当网要处理这块Redis是单线程的，基于Redis的贯彻则坐单线程的故在编码角度不用太多着想到和逻辑无关的题材。

　　简单介绍下，Redis是一个内存数据库，这个数据库属于非关系型数据库，它的概念不同让一般的我们体会的Mysql澳门新葡亰官网
Oracle
SqlServer关系型数据库，它并未Sql没有字段名没有表名这些概念，它和HttpRunTime.Cache的概念差不多一样，首先由操作上属于键值对模式，就使
Cache[“键名”]
这样就算会得到到价值类似，而且可针对每个Key设置过策略，而Redis中的Key所对应之值并无是怀念存啥就存啥的，它支持五种多少列：string（字符串），hash（哈希），list（列表），set（集合）及sorted
set（有序聚集)。

今日如果说之是Sorted
set有序聚集，有序聚集相比另的集聚类型的特别点在，使用有序聚集的时候还能吃插入的要素指定一个
积分score，我们将这个积分score理解啊破除序列，它里面会对积分进行排序，积分允许再，而有序聚集中之要素虽然是绝无仅有。

　　还是一样的思绪，每当发生用户访问的时候，都指向拖欠用户之
管道（有序聚集）中补充加一个因素，然后设置该因素的积分也当下光阴。接着在程序中开始个线程，来对管道被积分小于约定时间的因素进行清理。因为规定有序聚集中之元素只能是唯一值，所以当赋值方面只要是满足uuid即可。

那么因此Redis来兑现之代码那就算是类似这种：

透过using语法糖实现IDisposable而包的Redis分布式锁，然后中间正常的逻辑判断。

然的代码虽然为能够形成功能，但切莫敷自己。Redis是只依据内存的数据库，于性能而言，瓶颈在于网络
IO 上，与Get一不成发生同样次于呼吁相比，能无克经过一样段脚本来实现多数逻辑吗？

有的，Redis支持 Lua脚本：
　　Lua
是如出一辙种轻量小巧的脚本语言，用专业C语言编写并因为自代码形式开放，
其设计目的是为了放置应用程序中，从而为应用程序提供灵活的扩展和定制功能。
　　大致意思就是是，直接通往Redis发送一截脚本或者受它一直本地读取一段脚本从而直接实现有的逻辑。

/// <summary>
/// 如果 大于10(AccountNum) 就返回1   否则就增加一条集合中的元素 并返回 空
/// </summary>
/// <param name="zcardKey"></param>
/// <param name="score"></param>
/// <param name="zcardValue"></param>
/// <param name="AccountNum"></param>
/// <returns></returns>
public string LuaAddAccoundSorted(string zcardKey, double score, string zcardValue, int AccountNum)
{
    string str = "local uu = redis.call('zcard',@zcardKey) if (uu >=tonumber(@AccountNum)) then return 1 else redis.call('zadd',@zcardKey,@score,@zcardValue)  end";
    var re = _instance.GetDatabase(_num).ScriptEvaluate(LuaScript.Prepare(str), new { zcardKey = zcardKey, score = score, zcardValue = zcardValue, AccountNum=AccountNum });
    return re.ToString();
}

local
uu就是表明一个啊名uu的变量的意思，redis.call就是redis命令，这段脚本意思就是是一旦
大于10(AccountNum) 就返回1   否则就是加一长集合中之元素 并回到 空。

管道内元素处理的法门就是：

 /// <summary>
 /// 遍历当前所有前缀的有序集合，如果数量为0，那么就返回1 否则 就删除 满足最大分值条件区间的元素，如果该集合个数为0则消失
 /// </summary>
 /// <param name="zcardPrefix"></param>
 /// <param name="score"></param>
 /// <returns></returns>
public string LuaForeachRemove(string zcardPrefix, double score)
 {
     StringBuilder str = new StringBuilder();
     str.Append("local uu = redis.call('keys',@zcardPrefix) "); //声明一个变量 去获取 模糊查询的结果集合
     str.Append("if(#uu==0) then");    //如果集合长度=0
     str.Append("   return 1 ");
     str.Append("else ");
     str.Append("   for i=1,#uu do ");   //遍历
     str.Append("       redis.call('ZREMRANGEBYSCORE',uu[i],0,@score) ");  //删除从0 到 该score 积分区间的元素
     str.Append("       if(redis.call('zcard',uu[i])==0) then ");  //如果管道长度=0
     str.Append("           redis.call('del',uu[i]) ");   //删除
     str.Append("       end ");
     str.Append("   end ");
     str.Append("end ");
     var re = _instance.GetDatabase(_num).ScriptEvaluate(LuaScript.Prepare(str.ToString()), new { zcardPrefix = zcardPrefix + "*", score = score });
     return re.ToString();

立马2段落代码通过发送Lua脚本的款型来形成了全部过程，因为Redis的网络型原因，所以管LuaForeachRemove方法为取出来开只服务来单独处理即可。至于那种多容器多线程的实现，则一心可初步多只Redis的实例来实现。最后放上效果图。

最终，我将这些都受做成了个Demo。但是没找到合适的上传网盘，所以大家可以留邮箱（留了便作），或者直接加QQ群文件自取，讨论交流：166843154

本身爱好跟本身同样的口交朋友，不吃环境影响，自己是投机之师资，欢迎加群
.Net web交流群， QQ群：166843154 欲望与挣扎

作者：小曾
出处：http://www.cnblogs.com/1996V/p/8127576.html 欢迎转载，但任何转载必须保留完整文章及博客园出处，在显要地方显示署名以及原文链接。
.Net交流群， QQ群：166843154 欲望与挣扎