当前位置: 开发笔记 > 运维 > 正文

C#请求唯一性校验支持高并发的实现方法

作者：90后的中老年人 | 来源：互联网 | 2022-03-17 21:33

这篇文章主要给大家介绍了关于C#请求唯一性校验支持高并发的实现方法，文中通过示例代码介绍的非常详细，对大家学习或者使用C#具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧

使用场景描述：

　　网络请求中经常会遇到发送的请求，服务端响应是成功的，但是返回的时候出现网络故障，导致客户端无法接收到请求结果，那么客户端程序可能判断为网络故障，而重复发送同一个请求。当然如果接口中定义了请求结果查询接口，那么这种重复会相对少一些。特别是交易类的数据，这种操作更是需要避免重复发送请求。另外一种情况是用户过于快速的点击界面按钮，产生连续的相同内容请求，那么后端也需要进行过滤，这种一般出现在系统对接上，无法去控制第三方系统的业务逻辑，需要从自身业务逻辑里面去限定。

其他需求描述：

　　这类请求一般存在时间范围和高并发的特点，就是短时间内会出现重复的请求，因此对模块需要支持高并发性。

技术实现：

　　对请求的业务内容进行MD5摘要，并且将MD5摘要存储到缓存中，每个请求数据都通过这个一个公共的调用的方法进行判断。

代码实现：

　　公共调用代码 UniqueCheck 采用单例模式创建唯一对象，便于在多线程调用的时候，只访问一个统一的缓存库

/*
   * volatile就像大家更熟悉的const一样，volatile是一个类型修饰符（type specifier）。
   * 它是被设计用来修饰被不同线程访问和修改的变量。
   * 如果没有volatile，基本上会导致这样的结果：要么无法编写多线程程序，要么编译器失去大量优化的机会。
   */
  private static readonly object lockHelper = new object();
 
  private volatile static UniqueCheck _instance;  
 
  /// 
  /// 获取单一实例
  /// 
  /// 
  public static UniqueCheck GetInstance()
  {
   if (_instance == null)
   {
    lock (lockHelper)
    {
     if (_instance == null)
      _instance = new UniqueCheck();
    }
   }
   return _instance;
  }

　　这里需要注意volatile的修饰符，在实际测试过程中，如果没有此修饰符，在高并发的情况下会出现报错。

　　自定义一个可以进行并发处理队列，代码如下：ConcurrentLinkedQueue

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;

namespace PackgeUniqueCheck
{
 /// 
 /// 非加锁并发队列，处理100个并发数以内
 /// 
 /// 
 public class ConcurrentLinkedQueue
 {
  private class Node
  {
   internal K Item;
   internal Node Next;

   public Node(K item, Node next)
   {
    this.Item = item;
    this.Next = next;
   }
  }

  private Node _head;
  private Node _tail;

  public ConcurrentLinkedQueue()
  {
   _head = new Node(default(T), null);
   _tail = _head;
  }

  public bool IsEmpty
  {
   get { return (_head.Next == null); }
  }
  /// 
  /// 进入队列
  /// 
  /// 
  public void Enqueue(T item)
  {
   Node newNode = new Node(item, null);
   while (true)
   {
    Node curTail = _tail;
    Node residue = curTail.Next;

    //判断_tail是否被其他process改变
    if (curTail == _tail)
    {
     //A 有其他process执行C成功，_tail应该指向新的节点
     if (residue == null)
     {
      //C 其他process改变了tail节点，需要重新取tail节点
      if (Interlocked.CompareExchange>(
       ref curTail.Next, newNode, residue) == residue)
      {
       //D 尝试修改tail
       Interlocked.CompareExchange>(ref _tail, newNode, curTail);
       return;
      }
     }
     else
     {
      //B 帮助其他线程完成D操作
      Interlocked.CompareExchange>(ref _tail, residue, curTail);
     }
    }
   }
  }
  /// 
  /// 队列取数据
  /// 
  /// 
  /// 
  public bool TryDequeue(out T result)
  {
   Node curHead;
   Node curTail;
   Node next;
   while (true)
   {
    curHead = _head;
    curTail = _tail;
    next = curHead.Next;
    if (curHead == _head)
    {
     if (next == null)　//Queue为空
     {
      result = default(T);
      return false;
     }
     if (curHead == curTail) //Queue处于Enqueue第一个node的过程中
     {
      //尝试帮助其他Process完成操作
      Interlocked.CompareExchange>(ref _tail, next, curTail);
     }
     else
     {
      //取next.Item必须放到CAS之前
      result = next.Item;
      //如果_head没有发生改变，则将_head指向next并退出
      if (Interlocked.CompareExchange>(ref _head,
       next, curHead) == curHead)
       break;
     }
    }
   }
   return true;
  }
  /// 
  /// 尝试获取最后一个对象
  /// 
  /// 
  /// 
  public bool TryGetTail(out T result)
  {
   result = default(T);
   if (_tail == null)
   {
    return false;
   }
   result = _tail.Item;
   return true;
  }
 }
}

虽然是一个非常简单的唯一性校验逻辑，但是要做到高效率，高并发支持，高可靠性，以及低内存占用，需要实现这样的需求，需要做细致的模拟测试。

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Collections;

namespace PackgeUniqueCheck
{
 public class UniqueCheck
 {
  /*
   * volatile就像大家更熟悉的const一样，volatile是一个类型修饰符（type specifier）。
   * 它是被设计用来修饰被不同线程访问和修改的变量。
   * 如果没有volatile，基本上会导致这样的结果：要么无法编写多线程程序，要么编译器失去大量优化的机会。
   */
  private static readonly object lockHelper = new object();

  private volatile static UniqueCheck _instance;  

  /// 
  /// 获取单一实例
  /// 
  /// 
  public static UniqueCheck GetInstance()
  {
   if (_instance == null)
   {
    lock (lockHelper)
    {
     if (_instance == null)
      _instance = new UniqueCheck();
    }
   }
   return _instance;
  }

  private UniqueCheck()
  {
   //创建一个线程安全的哈希表，作为字典缓存
   _DataKey = Hashtable.Synchronized(new Hashtable());
   Queue myqueue = new Queue();
   _DataQueue = Queue.Synchronized(myqueue);
   _Myqueue = new ConcurrentLinkedQueue();
   _Timer = new Thread(DoTicket);
   _Timer.Start();
  }

  #region 公共属性设置
  /// 
  /// 设定定时线程的休眠时间长度：默认为1分钟
  /// 时间范围：1-7200000,值为1毫秒到2小时
  /// 
  /// 
  public void SetTimeSpan(int value)
  {
   if (value > 0&& value <=7200000)
   {
    _TimeSpan = value;
   }
  }
  /// 
  /// 设定缓存Cache中的最大记录条数
  /// 值范围：1-5000000,1到500万
  /// 
  /// 
  public void SetCacheMaxNum(int value)
  {
   if (value > 0 && value <= 5000000)
   {
    _CacheMaxNum = value;
   }
  }
  /// 
  /// 设置是否在控制台中显示日志
  /// 
  /// 
  public void SetIsShowMsg(bool value)
  {
   Helper.IsShowMsg = value;
  }
  /// 
  /// 线程请求阻塞增量
  /// 值范围：1-CacheMaxNum，建议设置为缓存最大值的10%-20%
  /// 
  /// 
  public void SetBlockNumExt(int value)
  {
   if (value > 0 && value <= _CacheMaxNum)
   {
    _BlockNumExt = value;
   }
  }
  /// 
  /// 请求阻塞时间
  /// 值范围：1-max，根据阻塞增量设置请求阻塞时间
  /// 阻塞时间越长，阻塞增量可以设置越大，但是请求实时响应就越差
  /// 
  /// 
  public void SetBlockSpanTime(int value)
  {
   if (value > 0)
   {
    _BlockSpanTime = value;
   }
  }
  #endregion

  #region 私有变量
  /// 
  /// 内部运行线程
  /// 
  private Thread _runner = null;
  /// 
  /// 可处理高并发的队列
  /// 
  private ConcurrentLinkedQueue _Myqueue = null;
  /// 
  /// 唯一内容的时间健值对
  /// 
  private Hashtable _DataKey = null;
  /// 
  /// 内容时间队列
  /// 
  private Queue _DataQueue = null;
  /// 
  /// 定时线程的休眠时间长度：默认为1分钟
  /// 
  private int _TimeSpan = 3000;
  /// 
  /// 定时计时器线程
  /// 
  private Thread _Timer = null;
  /// 
  /// 缓存Cache中的最大记录条数
  /// 
  private int _CacheMaxNum = 500000;
  /// 
  /// 线程请求阻塞增量
  /// 
  private int _BlockNumExt = 10000;
  /// 
  /// 请求阻塞时间
  /// 
  private int _BlockSpanTime = 100;
  #endregion

  #region 私有方法
  private void StartRun()
  {
   _runner = new Thread(DoAction);
   _runner.Start();
   Helper.ShowMsg("内部线程启动成功！");
  }

  private string GetItem()
  {
   string tp = string.Empty;
   bool result = _Myqueue.TryDequeue(out tp);
   return tp;
  }
  /// 
  /// 执行循环操作
  /// 
  private void DoAction()
  {
   while (true)
   {
    while (!_Myqueue.IsEmpty)
    {
     string item = GetItem();
     _DataQueue.Enqueue(item);
     if (!_DataKey.ContainsKey(item))
     {
      _DataKey.Add(item, DateTime.Now);
     }
    }
    //Helper.ShowMsg("当前数组已经为空，处理线程进入休眠状态...");
    Thread.Sleep(2);
   }
  }
  /// 
  /// 执行定时器的动作
  /// 
  private void DoTicket()
  {
   while (true)
   {
    Helper.ShowMsg("当前数据队列个数：" + _DataQueue.Count.ToString());
    if (_DataQueue.Count > _CacheMaxNum)
    {
     while (true)
     {
      Helper.ShowMsg(string.Format("当前队列数：{0}，已经超出最大长度：{1},开始进行清理操作...", _DataQueue.Count, _CacheMaxNum.ToString()));
      string item = _DataQueue.Dequeue().ToString();
      if (!string.IsNullOrEmpty(item))
      {
       if (_DataKey.ContainsKey(item))
       {
        _DataKey.Remove(item);
       }
       if (_DataQueue.Count <= _CacheMaxNum)
       {
        Helper.ShowMsg("清理完成，开始休眠清理线程...");
        break;
       }
      }
     }
    }
    Thread.Sleep(_TimeSpan);
   }
  }

  /// 
  /// 线程进行睡眠等待
  /// 如果当前负载压力大大超出了线程的处理能力
  /// 那么需要进行延时调用
  /// 
  private void BlockThread()
  {
   if (_DataQueue.Count > _CacheMaxNum + _BlockNumExt)
   {
    Thread.Sleep(_BlockSpanTime);
   }
  }
  #endregion

  #region 公共方法
  /// 
  /// 开启服务线程
  /// 
  public void Start()
  {
   if (_runner == null)
   {
    StartRun();
   }
   else
   {
    if (_runner.IsAlive == false)
    {
     StartRun();
    }
   }

  }
  /// 
  /// 关闭服务线程
  /// 
  public void Stop()
  {
   if (_runner != null)
   {
    _runner.Abort();
    _runner = null;
   }
  }

  /// 
  /// 添加内容信息
  /// 
  /// 内容信息
  /// true:缓存中不包含此值，队列添加成功，false:缓存中包含此值，队列添加失败
  public bool AddItem(string item)
  {
   BlockThread();
   item = Helper.MakeMd5(item);
   if (_DataKey.ContainsKey(item))
   {
    return false;
   }
   else
   {
    _Myqueue.Enqueue(item);
    return true;
   }
  }
  /// 
  /// 判断内容信息是否已经存在
  /// 
  /// 内容信息
  /// true：信息已经存在于缓存中，false：信息不存在于缓存中
  public bool CheckItem(string item)
  {
   item = Helper.MakeMd5(item);
   return _DataKey.ContainsKey(item);
  }
  #endregion 

 }
}

模拟测试代码：

private static string _example = Guid.NewGuid().ToString();

  private static UniqueCheck _uck = null;

  static void Main(string[] args)
  {
   _uck = UniqueCheck.GetInstance();
   _uck.Start();
   _uck.SetIsShowMsg(false);
   _uck.SetCacheMaxNum(20000000);
   _uck.SetBlockNumExt(1000000);
   _uck.SetTimeSpan(6000);

   _uck.AddItem(_example);
   Thread[] threads = new Thread[20];

   for (int i = 0; i <20; i++)
   {
    threads[i] = new Thread(AddInfo);
    threads[i].Start();
   }

   Thread checkthread = new Thread(CheckInfo);
   checkthread.Start();

   string value = Console.ReadLine();

   checkthread.Abort();
   for (int i = 0; i <50; i++)
   {
    threads[i].Abort();
   }
   _uck.Stop();
  }

  static void AddInfo()
  {
   while (true)
   {
    _uck.AddItem(Guid.NewGuid().ToString());
   }
  }

  static void CheckInfo()
  {
   while (true)
   {
    Console.WriteLine("开始时间：{0}...", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.ffff"));
    Console.WriteLine("插入结果：{0}", _uck.AddItem(_example));
    Console.WriteLine("结束时间：{0}", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.ffff"));
　　　　　　　　　 //调整进程休眠时间，可以测试高并发的情况
    //Thread.Sleep(1000);
   }
   
  }

测试截图：

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，谢谢大家对的支持。

安全
ssh

推荐阅读

服务器
跨平台SSH工具的全面指南

本文详细介绍了SSH（Secure Shell）的基础知识、应用场景以及如何在不同平台上使用SSH进行安全的远程操作。文章还探讨了SSH的高级用法，如免密登录和其他安全增强措施。 ... [详细]

蜡笔小新 2024-12-09 19:39:05
ssh
Gitee + Git 多人协作开发指南：轻松上手，解决代码冲突

本文提供了一套详细的步骤，帮助团队成员快速安装和配置Git，通过Gitee进行高效的多人协作开发，同时解决常见的代码冲突问题。包括Git的下载、安装、与Gitee的集成以及项目管理的最佳实践。 ... [详细]

蜡笔小新 2024-12-08 22:25:34
server
Java与PHP毕业设计题目精选

本文汇总了一系列适合Java和PHP毕业设计的题目，涵盖多个领域，旨在帮助即将完成学业的学生们找到合适的项目方向。 ... [详细]

蜡笔小新 2024-12-08 15:27:01
服务器
使用亚马逊免费服务部署Discuz!论坛指南（第一部分）

本文将指导您如何利用亚马逊AWS提供的12个月免费试用服务来部署Discuz!论坛。仅需一张信用卡即可轻松注册并开始使用。文章将详细介绍从账号注册到实例创建的具体步骤。 ... [详细]

蜡笔小新 2024-12-08 08:54:49
服务器
利用动态端口加强WinRM与OpenSSH服务器安全性

本文介绍了通过动态端口技术增强Windows远程管理（WinRM）及OpenSSH服务的安全性方案。此方案旨在提高服务器抵御DDoS攻击的能力，并减少因固定端口暴露而带来的安全风险。 ... [详细]

蜡笔小新 2024-12-08 03:57:53
服务器
Linux环境下配置Subclipse访问SVN+SSH仓库的方法

本文详细介绍如何在Linux操作系统中配置Subclipse，以便通过SSH协议安全访问SVN仓库。不同于常见的Windows配置指南，本文提供了针对Linux用户的详细步骤。 ... [详细]

蜡笔小新 2024-12-07 20:20:13
port
利用SecureCRT实现远程连接树莓派

本文介绍了如何使用SecureCRT软件通过网络远程连接和管理树莓派的方法，包括获取树莓派的IP地址、配置SecureCRT以及完成安全连接的具体步骤。 ... [详细]

蜡笔小新 2024-12-09 16:49:27
service
解决MySQL错误2002：无法建立数据库连接

本文详细描述了在Digital Ocean服务器上托管的多个WordPress站点突然出现数据库连接错误的情况，并提供了有效的解决方案。 ... [详细]

蜡笔小新 2024-12-09 16:12:42
ssh
EVE-NG镜像扩充，迈向新高度！

关注EmulatedLab微信公众号，获取最新文章及下载链接。本文将详细介绍EVE-NG的最新镜像更新，包括新增功能和使用技巧。 ... [详细]

蜡笔小新 2024-12-09 15:40:26
ssh
DirectX11教程：利用几何着色器实现简易Billboard

本文通过实现一个基于几何着色器（Geometry Shader）的Billboard案例，深入探讨DirectX 11中几何着色器的功能与应用。文章详细介绍了如何在顶点着色器中处理顶点数据，并在几何着色器中生成面向摄像机的四边形。 ... [详细]

蜡笔小新 2024-12-08 19:19:32
ssh
在Swift项目中集成Objective-C类或第三方框架的方法

本文通过实例讲解如何在Swift项目中引入并使用Objective-C编写的ProgressHUD库。首先需要在项目中添加库文件，并设置Objective-C桥接头文件以实现语言间的互操作性。 ... [详细]

蜡笔小新 2024-12-08 18:22:21
ssh
我们如何用下划线Java‽

我目前正在通过以下编程练习进行训练： ... [详细]

蜡笔小新 2024-12-08 12:59:15
linux
实现三台虚拟机间的无密码SSH登录

本文介绍如何配置三台名为node01、node02和node03的虚拟机，以实现它们之间通过SSH进行无密码登录的过程。包括密钥对的生成、公钥的分发以及最终的登录测试。 ... [详细]

蜡笔小新 2024-12-06 17:44:53
服务器
Windows 10 上低配置也能畅玩的免费单机游戏推荐

探索Windows 10平台上一系列免费且对硬件要求不高的单机游戏。尽管Windows 10以其先进的DX12技术著称，但游戏的兼容性和稳定性同样重要。本文将详细介绍几款适合低配置电脑的优秀游戏。 ... [详细]

蜡笔小新 2024-12-06 13:47:03
service
提升SSH安全性：两种方法限制特定IP访问

为了增强服务器的安全性，管理员可以通过SSH进行精细的访问控制。本文将介绍两种有效的方法来限制用户从特定IP地址登录，包括更改默认端口和设置允许访问的IP列表。 ... [详细]

蜡笔小新 2024-12-04 08:11:24

90后的中老年人

这个家伙很懒，什么也没留下！

Tags | 热门标签

RankList | 热门文章