浅谈C#在网络波动时防重复提交的方法

前几天,公司数据库出现了两条相同的数据,而且时间相同(毫秒也相同)。排查原因,发现是网络波动造成了重复提交。

由于网络波动而重复提交的例子也比较多:

网络上,防重复提交的方法也很多,使用redis锁,代码层面使用lock。

但是,我没有发现一个符合我心意的解决方案。因为网上的解决方案,第一次提交返回成功,第二次提交返回失败。由于两次返回信息不一致,一次成功一次失败,我们不确定客户端是以哪个返回信息为准,虽然我们希望客户端以第一次返回成功的信息为准,但客户端也可能以第二次失败信息运行,这是一个不确定的结果。

在重复提交后,如果客户端的接收到的信息都相同,都是成功,那客户端就可以正常运行,就不会影响用户体验。

我想到一个缓存类,来源于PetaPoco。

Cache<TKey, TValue>代码如下:

public class Cache<TKey, TValue>
  {
    private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();
    private readonly Dictionary<TKey, TValue> _map = new Dictionary<TKey, TValue>();

    public int Count {
      get { return _map.Count; }
    }

    public TValue Execute(TKey key, Func<TValue> factory)
    {
      // Check cache
      _lock.EnterReadLock();
      TValue val;
      try {
        if (_map.TryGetValue(key, out val))
          return val;
      } finally {
        _lock.ExitReadLock();
      }

      // Cache it
      _lock.EnterWriteLock();
      try {
        // Check again
        if (_map.TryGetValue(key, out val))
          return val;

        // Create it
        val = factory();

        // Store it
        _map.Add(key, val);

        // Done
        return val;
      } finally {
        _lock.ExitWriteLock();
      }
    }

    public void Clear()
    {
      // Cache it
      _lock.EnterWriteLock();
      try {
        _map.Clear();
      } finally {
        _lock.ExitWriteLock();
      }
    }
  }

Cache<TKey, TValue>符合我的要求,第一次运行后,会将值缓存,第二次提交会返回第一次的值。

但是,细细分析Cache<TKey, TValue> 类,可以发现有以下几个缺点

1、 不会自动清空缓存,适合一些key不多的数据,不适合做为网络接口。

2、 由于_lock.EnterWriteLock,多线程会变成并单线程,不适合做为网络接口。

3、 没有过期缓存判断。

于是我对Cache<TKey, TValue>进行改造。

AntiDupCache代码如下:

/// <summary>
  /// 防重复缓存
  /// </summary>
  /// <typeparam name="TKey"></typeparam>
  /// <typeparam name="TValue"></typeparam>
  public class AntiDupCache<TKey, TValue>
  {
    private readonly int _maxCount;//缓存最高数量
    private readonly long _expireTicks;//超时 Ticks
    private long _lastTicks;//最后Ticks
    private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();
    private readonly ReaderWriterLockSlim _slimLock = new ReaderWriterLockSlim();
    private readonly Dictionary<TKey, Tuple<long, TValue>> _map = new Dictionary<TKey, Tuple<long, TValue>>();
    private readonly Dictionary<TKey, AntiDupLockSlim> _lockDict = new Dictionary<TKey, AntiDupLockSlim>();
    private readonly Queue<TKey> _queue = new Queue<TKey>();
    class AntiDupLockSlim : ReaderWriterLockSlim { public int UseCount; }

    /// <summary>
    /// 防重复缓存
    /// </summary>
    /// <param name="maxCount">缓存最高数量,0 不缓存,-1 缓存所有</param>
    /// <param name="expireSecond">超时秒数,0 不缓存,-1 永久缓存 </param>
    public AntiDupCache(int maxCount = 100, int expireSecond = 1)
    {
      if (maxCount < 0) {
        _maxCount = -1;
      } else {
        _maxCount = maxCount;
      }
      if (expireSecond < 0) {
        _expireTicks = -1;
      } else {
        _expireTicks = expireSecond * TimeSpan.FromSeconds(1).Ticks;
      }
    }

    /// <summary>
    /// 个数
    /// </summary>
    public int Count {
      get { return _map.Count; }
    }

    /// <summary>
    /// 执行
    /// </summary>
    /// <param name="key">值</param>
    /// <param name="factory">执行方法</param>
    /// <returns></returns>
    public TValue Execute(TKey key, Func<TValue> factory)
    {
      // 过期时间为0 则不缓存
      if (object.Equals(null, key) || _expireTicks == 0L || _maxCount == 0) { return factory(); }

      Tuple<long, TValue> tuple;
      long lastTicks;
      _lock.EnterReadLock();
      try {
        if (_map.TryGetValue(key, out tuple)) {
          if (_expireTicks == -1) return tuple.Item2;
          if (tuple.Item1 + _expireTicks > DateTime.Now.Ticks) return tuple.Item2;
        }
        lastTicks = _lastTicks;
      } finally { _lock.ExitReadLock(); }

      AntiDupLockSlim slim;
      _slimLock.EnterUpgradeableReadLock();
      try {
        _lock.EnterReadLock();
        try {
          if (_lastTicks != lastTicks) {
            if (_map.TryGetValue(key, out tuple)) {
              if (_expireTicks == -1) return tuple.Item2;
              if (tuple.Item1 + _expireTicks > DateTime.Now.Ticks) return tuple.Item2;
            }
            lastTicks = _lastTicks;
          }
        } finally { _lock.ExitReadLock(); }

        _slimLock.EnterWriteLock();
        try {
          if (_lockDict.TryGetValue(key, out slim) == false) {
            slim = new AntiDupLockSlim();
            _lockDict[key] = slim;
          }
          slim.UseCount++;
        } finally { _slimLock.ExitWriteLock(); }
      } finally { _slimLock.ExitUpgradeableReadLock(); }

      slim.EnterWriteLock();
      try {
        _lock.EnterReadLock();
        try {
          if (_lastTicks != lastTicks && _map.TryGetValue(key, out tuple)) {
            if (_expireTicks == -1) return tuple.Item2;
            if (tuple.Item1 + _expireTicks > DateTime.Now.Ticks) return tuple.Item2;
          }
        } finally { _lock.ExitReadLock(); }

        var val = factory();
        _lock.EnterWriteLock();
        try {
          _lastTicks = DateTime.Now.Ticks;
          _map[key] = Tuple.Create(_lastTicks, val);
          if (_maxCount > 0) {
            if (_queue.Contains(key) == false) {
              _queue.Enqueue(key);
              if (_queue.Count > _maxCount) _map.Remove(_queue.Dequeue());
            }
          }
        } finally { _lock.ExitWriteLock(); }
        return val;
      } finally {
        slim.ExitWriteLock();
        _slimLock.EnterWriteLock();
        try {
          slim.UseCount--;
          if (slim.UseCount == 0) {
            _lockDict.Remove(key);
            slim.Dispose();
          }
        } finally { _slimLock.ExitWriteLock(); }
      }
    }
    /// <summary>
    /// 清空
    /// </summary>
    public void Clear()
    {
      _lock.EnterWriteLock();
      try {
        _map.Clear();
        _queue.Clear();
        _slimLock.EnterWriteLock();
        try {
          _lockDict.Clear();
        } finally {
          _slimLock.ExitWriteLock();
        }
      } finally {
        _lock.ExitWriteLock();
      }
    }

  }

代码分析:

使用两个ReaderWriterLockSlim锁 + 一个AntiDupLockSlim锁,实现并发功能。

Dictionary<TKey, Tuple<long, TValue>> _map实现缓存,long类型值记录时间,实现缓存过期

int _maxCount + Queue<TKey> _queue,_queue 记录key列队,当数量大于_maxCount,清除多余缓存。

AntiDupLockSlim继承ReaderWriterLockSlim,实现垃圾回收,

代码使用 :

private readonly static AntiDupCache<int, int> antiDupCache = new AntiDupCache<int, int>(50, 1);

  antiDupCache.Execute(key, () => {

     ....

     return val;

  });

测试性能数据:

----------------------- 开始  从1到100   重复次数:1 单位: ms -----------------------

并发数量: 1    2    3    4    5    6    7    8    9    10   11   12

普通并发: 188  93   65   46   38   36   28   31   22   20   18   19

AntiDupCache: 190  97   63   48   37   34   29   30   22   18   17   21

AntiDupQueue: 188  95   63   46   37   33   30   25   21   19   17   21

DictCache: 185  96   64   47   38   33   28   29   22   19   17   21

Cache: 185  186  186  188  188  188  184  179  180  184  184  176

第二次普通并发: 180  92   63   47   38   36   26   28   20   17   16   20

----------------------- 开始  从1到100   重复次数:2 单位: ms -----------------------

并发数量: 1    2    3    4    5    6    7    8    9    10   11   12

普通并发: 368  191  124  93   73   61   55   47   44   37   34   44

AntiDupCache: 180  90   66   48   37   31   28   24   21   17   17   22

AntiDupQueue: 181  93   65   46   39   31   27   23   21   19   18   19

DictCache: 176  97   61   46   38   30   31   23   21   18   18   22

Cache: 183  187  186  182  186  185  184  177  181  177  176  177

第二次普通并发: 366  185  127  95   71   62   56   48   43   38   34   43

----------------------- 开始  从1到100   重复次数:4 单位: ms -----------------------

并发数量: 1    2    3    4    5    6    7    8    9    10   11   12

普通并发: 726  371  253  190  152  132  106  91   86   74   71   69

AntiDupCache: 189  95   64   49   37   33   28   26   22   19   17   18

AntiDupQueue: 184  97   65   51   39   35   28   24   21   18   17   17

DictCache: 182  95   64   45   39   34   29   23   21   18   18   16

Cache: 170  181  180  184  182  183  181  181  176  179  179  178

第二次普通并发: 723  375  250  186  150  129  107  94   87   74   71   67

----------------------- 开始  从1到100   重复次数:12 单位: ms -----------------------

并发数量: 1    2    3    4    5    6    7    8    9    10   11   12

普通并发: 2170 1108 762  569  450  389  325  283  253  228  206  186

AntiDupCache: 182  95   64   51   41   32   28   25   26   20   18   18

AntiDupQueue: 189  93   67   44   37   35   29   30   27   22   20   17

DictCache: 184  97   59   50   38   29   27   26   24   19   18   17

Cache: 174  189  181  184  184  177  182  180  176  176  180  179

第二次普通并发: 2190 1116 753  560  456  377  324  286  249  227  202  189

仿线上环境,性能测试数据:

----------------------- 仿线上环境  从1到1000  单位: ms -----------------------

并发数量: 1    2    3    4    5    6    7    8    9    10   11   12

普通并发: 1852 950  636  480  388  331  280  241  213  198  181  168

AntiDupCache: 1844 949  633  481  382  320  267  239  210  195  174  170

AntiDupQueue: 1835 929  628  479  386  318  272  241  208  194  174  166

DictCache: 1841 935  629  480  378  324  269  241  207  199  176  168

Cache: 1832 1854 1851 1866 1858 1858 1832 1825 1801 1797 1788 1785

第二次普通并发: 1854 943  640  468  389  321  273  237  209  198  177  172

项目:

Github: https://github.com/toolgood/ToolGood.AntiDuplication

Nuget: Install-Package ToolGood.AntiDuplication

后记:

尝试添加 一个Queue<AntiDupLockSlim> 或Stack<AntiDupLockSlim> 用来缓存锁,后发现性能效率相差不大,上下浮动。

使用 lock关键字加锁,速度相差不大,代码看似更简单,但隐藏了一个地雷:一般人使用唯一键都是使用string,就意味着可能使用lock(string),锁定字符串尤其危险,因为字符串被公共语言运行库 (CLR)“暂留”。 这意味着整个程序中任何给定字符串都只有一个实例,就是这同一个对象表示了所有运行的应用程序域的所有线程中的该文本。因此,只要在应用程序进程中的任何位置处具有相同内容的字符串上放置了锁,就将锁定应用程序中该字符串的所有实例。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • Asp.Net防止刷新重复提交数据的办法

    在网上搜 一下,可以找到很多关于这方面的资料,其中有一篇是来自MSDN上的一种解决方法: http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnvs05/html/BedrockASPNET.asp 它是通过重新定义 System.Web.UI.Page 类来实现加载页面时,是"刷新"."后退"请求,还是正常请求,其他的页面则继承了自定义的这 个Page类.感觉他这个方法比较独特,有例子

  • asp.net 防止用户通过后退按钮重复提交表单

    防止用户通过后退按钮重复提交表单 <% response.Buffer=true response.Expires=0 response.ExpiresAbsolute=now()-1 response.CacheControl="no-cache" %> response.Buffer=true的意思就是指明输出页面是否被缓冲,当属性值为True时,服务器将不会向客户端发送任何信息,直到所有程序执行完或者遇到 <% Response.Flush %>或<

  • asp.net 处理F5刷新页面重复提交页面的一个思路

    当提交完一个页面后,如果我们再次点击F5刷新该页面的话,会弹出一个提示,提示我们如果继续,则会重新发送提交我们刚才提交的内容,要是类似付款或一次性的操作,我们不应该这样操作,否则会造成重复提交的问题.解决这个问题,我们可以通过如下思路来处理: 1. 提交成功后,将一个成功状态存入session中,然后重新载入该页面. 2. 在page_load方法中,判定该session字段的状态值,如果为成功,则显示成功信息,否则显示错误提示,紧跟着通过Session.Remove()方法来清空该缓存即可.

  • asp.net防止刷新时重复提交(可禁用工具条刷新按钮)

    前段时间遇到了需要禁用刷新的需求,f5按钮就不说了,简单的js就能把它禁用,但是工具条上的刷新按钮却傻傻干不掉. 如果简单的在刷新时重新加载画面,通过window.location.href="url"可以很容易的实现,但是需求是要求在刷新时什么都不做,保留画面的状态,这下子可就复杂化了. asp.net中分辨请求是重新请求还是通过刷新按钮再次请求不是很方便,为了实现这个效果,试过了很多的方式,一下面的两种为例 1. 复制代码 代码如下: private bool pageRefres

  • asp.net页面防止重复提交示例分享

    先放javascript代码: 复制代码 代码如下: <script type="text/javascript">        var clicks = 0;        function checkclick(obj) {            clicks = clicks + 1;            if (clicks>1) {                alert("请勿重复点击!");                ret

  • Asp.net防重复提交机制实现方法

    为Button或其他控件加上下面两个属性即可 1.UseSubmitBehavior="false"使用服务器端提交机制,即执行OnClick事件. 2.OnClientClick客户端点击按钮后,设置控件为不可用,控件文本显示处理中-,待服务器端执行完OnClick事件,控件自动恢复为可用. 代码如下: 复制代码 代码如下: UseSubmitBehavior="false" OnClientClick="this.disabled=true;this.

  • asp.net表单提交时防重复提交并执行前台的JS验证

    在项目开发中,遇到这样的一个情况,就是用户重复提交.当然这个不能怪用户,只能怪.NET或者服务器反应迟钝......我是这样理解的. 在网上搜了一下,解决方案是不少,比如: http://bbs.csdn.net/topics/340048988 (这个大家提了不少建议) http://www.cnblogs.com/blsong/archive/2009/12/24/1631144.html (这个基本上总结了网上的方法) 但实际上做互联网web项目中,需要在前台执行JS或者Jquery的验证

  • Asp.Net中避免重复提交和弹出提示框的实例代码

    前台代码: <asp:Button ID="Button1" runat="server" Text="打印" onclick="Button1_Click" OnClientClick="this.value='数据提交中--';this.disabled=true;" UseSubmitBehavior="False" /> 后台代码: public partial cl

  • ASP.NET中防止页面刷新造成表单重复提交执行两次操作

    之前看过别人防刷新的方法,是让页面刷新或返回上一步让页面过期,这里介绍一种另类的方法,使用Session来处理. 实现原理: 由于刷新提交表单,实际上提交的就是上一次正常提交的表单,所以我们只要做一个标志,判断出是新表单还是上一次的旧表单就可以分辨出是否进行了重复提交操作. 实现方法: 在页面上放置一个Hidden域,当页面第一次载入的时候,在Session里面保存一个标志,同时,把这个标志保存到页面上的Hidden里面.在提交表单时,判断表单中提交上来的Hidden和Session中的标志是否

  • 浅谈C#在网络波动时防重复提交的方法

    前几天,公司数据库出现了两条相同的数据,而且时间相同(毫秒也相同).排查原因,发现是网络波动造成了重复提交. 由于网络波动而重复提交的例子也比较多: 网络上,防重复提交的方法也很多,使用redis锁,代码层面使用lock. 但是,我没有发现一个符合我心意的解决方案.因为网上的解决方案,第一次提交返回成功,第二次提交返回失败.由于两次返回信息不一致,一次成功一次失败,我们不确定客户端是以哪个返回信息为准,虽然我们希望客户端以第一次返回成功的信息为准,但客户端也可能以第二次失败信息运行,这是一个不确

  • 浅谈axios中取消请求及阻止重复请求的方法

    目录 前言 核心--CancelToken 实际应用和封装 一些小细节 前言 在实际项目中,我们可能需要对请求进行"防抖"处理.这里主要是为了阻止用户在某些情况下短时间内重复点击某个按钮,导致前端向后端重复发送多次请求.这里我列举两种比较常见的实际情况: PC端 - 用户双击搜索按钮,可能会触发两次搜索请求 移动端 - 因移动端没有点击延迟,所以极易造成误操作或多操作,造成请求重发 以上情况有可能在有Loading遮罩时依然发生,所以我们要考虑前端阻止重复请求的方法. 核心--Canc

  • jquery提交form表单时禁止重复提交的方法

    复制代码 代码如下: $(document).ready(function() {  $('form').submit(function() {    if(typeof jQuery.data(this, "disabledOnSubmit") == 'undefined') {      jQuery.data(this, "disabledOnSubmit", { submited: true });      $('input[type=submit], i

  • 浅谈keras 模型用于预测时的注意事项

    为什么训练误差比测试误差高很多? 一个Keras的模型有两个模式:训练模式和测试模式.一些正则机制,如Dropout,L1/L2正则项在测试模式下将不被启用. 另外,训练误差是训练数据每个batch的误差的平均.在训练过程中,每个epoch起始时的batch的误差要大一些,而后面的batch的误差要小一些.另一方面,每个epoch结束时计算的测试误差是由模型在epoch结束时的状态决定的,这时候的网络将产生较小的误差. [Tips]可以通过定义回调函数将每个epoch的训练误差和测试误差并作图,

  • 浅谈js中调用函数时加不加括号的问题

    其实总结起来如下: 函数只要是要调用它进行执行的,都必须加括号.此时,函数()实际上等于函数的返回值.当然,有些没有返回值,但已经执行了函数体内的行为,这个是根本,就是说,只要加括号的,就代表将会执行函数体代码. 不加括号的,都是把函数名称作为函数的指针,用于传参,此时不是得到函数的结果,因为不会运行函数体代码.它只是传递了函数体所在的地址位置,在需要的时候好找到函数体去执行. 所以一般时候我们都是采用的是无括号的原因.这也是由于括号的二义性,因为括号是"函数调用运算符",相当于在执行

  • 浅谈keras中自定义二分类任务评价指标metrics的方法以及代码

    对于二分类任务,keras现有的评价指标只有binary_accuracy,即二分类准确率,但是评估模型的性能有时需要一些其他的评价指标,例如精确率,召回率,F1-score等等,因此需要使用keras提供的自定义评价函数功能构建出针对二分类任务的各类评价指标. keras提供的自定义评价函数功能需要以如下两个张量作为输入,并返回一个张量作为输出. y_true:数据集真实值组成的一阶张量. y_pred:数据集输出值组成的一阶张量. tf.round()可对张量四舍五入,因此tf.round(

  • 浅谈mysql中多表不关联查询的实现方法

    大家在使用MySQL查询时正常是直接一个表的查询,要不然也就是多表的关联查询,使用到了左联结(left join).右联结(right join).内联结(inner join).外联结(outer join).这种都是两个表之间有一定关联,也就是我们常常说的有一个外键对应关系,可以使用到 a.id = b.aId这种语句去写的关系了.这种是大家常常使用的,可是有时候我们会需要去同时查询两个或者是多个表的时候,这些表又是没有互相关联的,比如要查user表和user_history表中的某一些数据

  • 浅谈python字典多键值及重复键值的使用

    在python中使用字典,格式如下: dict={ key1:value1 , key2;value2 ...} 在实际访问字典值时的使用格式如下: dict[key] 多键值 字典的多键值形式如下: dict={(ke11,key12):value ,(key21,key22):value ...} 在实际访问字典里的值时的具体形式如下所示(以第一个键为例): dict[key11,key12] 或者是: dict[(key11,key12)] 以下是实际例子: 多值 在一个键值对应多个值时,

  • 浅谈Java中几种常见的比较器的实现方法

    在Java中经常会涉及到对象数组的排序问题,那么就涉及到对象之间的比较问题. 通常对象之间的比较可以从两个方面去看: 第一个方面:对象的地址是否一样,也就是是否引用自同一个对象.这种方式可以直接使用"=="来完成. 第二个方面:以对象的某一个属性的角度去比较. 从最新的JDK8而言,有三种实现对象比较的方法: 一.覆写Object类的equals()方法: 二.继承Comparable接口,并实现compareTo()方法: 三.定义一个单独的对象比较器,继承自Comparator接口

随机推荐