C#vb.net中Interlocked类实现原子操作加减计算,涵盖状态切换、计数控制等常见场景

已于 2025-08-12 10:41:40 修改
阅读量601 收藏 4
点赞数 17
CC 4.0 BY-SA版权
文章标签： java 数据库 前端
于 2025-08-12 10:39:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoyao961/article/details/150265156

以下是 C# 中使用 int 类型结合 Interlocked 类实现原子操作的完整示例，涵盖状态切换、计数控制等常见场景：

完整代码示例csharp

using System;
using System.Threading;

/// <summary>
/// 基于整数类型的原子操作工具类（线程安全）
/// 适用于开关状态控制、计数器等场景
/// </summary>
public static class AtomicStateManager
{
    // 核心状态变量：用整数表示不同状态
    // 示例场景：0=关闭（False），1=开启（True）；也可扩展为多状态（如0=未初始化，1=运行中，2=已停止）
    private static int _state = 0; 

    #region 基础状态控制（开关场景）
    /// <summary>
    /// 原子设置状态为“开启”（对应值1）
    /// </summary>
    public static void Enable()
    {
        // 直接将状态设为1，无视当前值（原子操作）
        Interlocked.Exchange(ref _state, 1);
    }

    /// <summary>
    /// 原子设置状态为“关闭”（对应值0）
    /// </summary>
    public static void Disable()
    {
        // 直接将状态设为0，无视当前值（原子操作）
        Interlocked.Exchange(ref _state, 0);
    }

    /// <summary>
    /// 原子切换状态（0→1 或 1→0）
    /// </summary>
    public static void Toggle()
    {
        // 循环尝试切换，直到成功（处理并发冲突）
        do
        {
            int currentState = _state; // 读取当前状态
            int newState = currentState == 1 ? 0 : 1; // 计算目标状态
            // 比较并交换：如果当前值仍为currentState，则更新为newState
            // 若交换失败（返回值≠currentState），则重试
        } while (Interlocked.CompareExchange(ref _state, newState, _state) != _state);
    }

    /// <summary>
    /// 原子读取当前状态是否为“开启”
    /// </summary>
    /// <returns>True=开启（1），False=关闭（0）</returns>
    public static bool IsEnabled()
    {
        // 用CompareExchange确保读取到最新值（避免CPU缓存导致的脏读）
        return Interlocked.CompareExchange(ref _state, 0, 0) == 1;
    }
    #endregion

    #region 计数器场景（原子增减）
    /// <summary>
    /// 原子递增状态值（+1）
    /// </summary>
    /// <returns>递增后的新值</returns>
    public static int Increment()
    {
        return Interlocked.Increment(ref _state);
    }

    /// <summary>
    /// 原子递减状态值（-1）
    /// </summary>
    /// <returns>递减后的新值</returns>
    public static int Decrement()
    {
        return Interlocked.Decrement(ref _state);
    }

    /// <summary>
    /// 原子读取当前计数值
    /// </summary>
    /// <returns>当前状态值</returns>
    public static int GetCount()
    {
        return Interlocked.CompareExchange(ref _state, 0, 0);
    }
    #endregion

    #region 高级场景：条件更新（仅当满足条件时修改）
    /// <summary>
    /// 仅当当前状态为“关闭”时，原子设置为“开启”
    /// </summary>
    /// <returns>True=更新成功，False=当前状态不满足条件</returns>
    public static bool EnableIfDisabled()
    {
        // 比较并交换：若当前值为0（关闭），则更新为1（开启）
        int originalValue = Interlocked.CompareExchange(ref _state, 1, 0);
        return originalValue == 0; // 若原始值为0，说明更新成功
    }

    /// <summary>
    /// 仅当当前状态为目标值时，原子更新为新值
    /// </summary>
    /// <param name="expectedValue">预期当前值</param>
    /// <param name="newValue">目标新值</param>
    /// <returns>True=更新成功，False=当前值不符预期</returns>
    public static bool UpdateIfMatch(int expectedValue, int newValue)
    {
        int originalValue = Interlocked.CompareExchange(ref _state, newValue, expectedValue);
        return originalValue == expectedValue;
    }
    #endregion
}

使用示例csharp

class Program
{
    static void Main()
    {
        // 1. 开关状态场景
        AtomicStateManager.Enable();
        Console.WriteLine($"是否开启：{AtomicStateManager.IsEnabled()}"); // 输出：True

        AtomicStateManager.Toggle();
        Console.WriteLine($"切换后是否开启：{AtomicStateManager.IsEnabled()}"); // 输出：False

        bool updateSuccess = AtomicStateManager.EnableIfDisabled();
        Console.WriteLine($"是否成功开启：{updateSuccess}"); // 输出：True
        Console.WriteLine($"当前状态：{AtomicStateManager.IsEnabled()}"); // 输出：True


        // 2. 计数器场景
        AtomicStateManager.Increment(); // 状态从1→2
        AtomicStateManager.Increment(); // 状态从2→3
        Console.WriteLine($"当前计数：{AtomicStateManager.GetCount()}"); // 输出：3

        AtomicStateManager.Decrement(); // 状态从3→2
        Console.WriteLine($"递减后计数：{AtomicStateManager.GetCount()}"); // 输出：2


        // 3. 条件更新场景
        bool conditionUpdate = AtomicStateManager.UpdateIfMatch(2, 100);
        Console.WriteLine($"条件更新是否成功：{conditionUpdate}"); // 输出：True
        Console.WriteLine($"更新后的值：{AtomicStateManager.GetCount()}"); // 输出：100
    }
}

核心原理与优势

  1. 原子性保证：
    Interlocked 类的方法通过底层硬件指令实现原子操作，确保操作过程不会被其他线程打断，避免竞态条件。

  2. 性能优化：
    相比 lock 等锁机制，Interlocked 操作无需上下文切换，开销更小，适合高频访问场景。

  3. 可见性保证：
    所有 Interlocked 操作会强制刷新 CPU 缓存，确保所有线程看到的是最新值，避免因缓存导致的数据不一致。

  4. 灵活性扩展：
    示例中用 0 和 1 表示开关状态，实际可扩展为多状态（如 0=未初始化、1=运行中、2=已停止），通过 UpdateIfMatch 方法实现复杂状态转换。

这种方式特别适合 IIS 等多线程环境下的全局变量控制，可有效避免并发修改导致的异常。

VB.NET的用法例子：

将布尔值转换为整数类型（如 Integer）后使用 Interlocked 类的原子操作（如递增、递减、比较交换），在多线程场景中会更直观且高效。这种方式特别适合需要 "开关状态切换" 或 "计数控制" 的场景。

以下是 VB.NET 中基于整数类型的原子操作实现，以 GetServerInfo 的状态控制为例：

实现示例：VB.NET 用整数类型模拟状态，结合原子操作

vb

Imports System.Threading

' 用整数表示状态：0=关闭（False），1=开启（True）
Private Shared _serverInfoState As Integer = 0 ' 初始状态：关闭

' 原子开启（设置为1）
Public Sub EnableServerInfo()
    Interlocked.Exchange(_serverInfoState, 1)
End Sub

' 原子关闭（设置为0）
Public Sub DisableServerInfo()
    Interlocked.Exchange(_serverInfoState, 0)
End Sub

' 原子切换状态（0→1 或 1→0）
Public Sub ToggleServerInfo()
    ' 循环尝试切换，直到成功（处理并发冲突）
    Do
        Dim currentState = _serverInfoState
        Dim newState = If(currentState = 1, 0, 1)
        ' 比较并交换：如果当前值仍为 currentState，则更新为 newState
    Loop While Interlocked.CompareExchange(_serverInfoState, newState, currentState) <> currentState
End Sub

' 原子读取当前状态
Public Function IsServerInfoEnabled() As Boolean
    ' 读取操作本身是原子的，但用 CompareExchange 确保可见性
    Return Interlocked.CompareExchange(_serverInfoState, 0, 0) = 1
End Function

' 原子递增（适合计数场景）
Public Sub IncrementCounter()
    Interlocked.Increment(_serverInfoState)
End Sub

' 原子递减（适合计数场景）
Public Sub DecrementCounter()
    Interlocked.Decrement(_serverInfoState)
End Sub

优势说明

  1. 操作直观：
    用 0 和 1 对应 False 和 True，通过 Interlocked.Increment/Decrement 可直接实现计数，无需额外转换逻辑。

  2. 性能优异：
    Interlocked 类的方法是底层硬件支持的原子操作，比 SyncLock 等锁机制开销更小，尤其适合高频访问的场景。

  3. 避免竞态条件：

    • Exchange 确保 "设置新值" 操作的原子性，不会被其他线程打断。
    • CompareExchange 结合循环可实现 "检查 - 更新" 的原子性（如 ToggleServerInfo 方法），避免并发下的状态不一致。

  4. 可见性保证：
    Interlocked 操作会强制刷新 CPU 缓存，确保所有线程看到的是最新值（避免因缓存导致的 "脏读"）。

适用场景

  • 简单的开关状态（如 GetServerInfo 的启用 / 禁用）。
  • 计数器（如统计并发请求数、操作次数）。
  • 需要原子 "检查并修改" 的逻辑（如仅当状态为关闭时才开启）。

如果你的场景涉及更复杂的状态转换（如多值状态），这种整数映射方式同样适用，只需扩展数值对应的含义即可（如 0=未初始化、1=运行中、2=已停止）。

[VB.NET]多线程——高级同步技术
VB.NET学习网-VB.NET实例、VB.NET教程、VB.NET源码下载
11-30 7508
多线程应用程序通常使用等待句柄和监视器对象来同步多个线程。下表介绍了可用于同步线程的部分 .NET 框架类。类 用途 AutoResetEvent  等待句柄，用于通知一个或多个等待线程发生了一个事件。AutoResetEvent 在等待线程被释放后自动将状态更改为已发出信号。  Interlocked  为多个线程共享的变量提供原子操作。 ManualResetEvent  等待句柄，用于通
C# 原子操作 Interlocked
wf824284257的博客
01-20 3944
前言 焦虑与恐惧，往往是是因为想要的太多，但行动却太少。将目标放低，并制定足以达到目标的计划，并付之于一步一个脚印的行动。当你确信你在前进的时候，自然就不会焦虑；当你的行动为你积累了足够多的正向改变的时候，自然就不会恐惧；当量变中迸发出那么一星星的质变时，你将变的自信。 足够强大，你才会自信。自信来源于强大的内心，强大的自己。 开始 Interlocked 提供了方法来实现原子操作，对于多线程共享...
.NET多线程同步方法详解(一)：自由锁(InterLocked)
小薛的Blog
10-30 6164
    本文主要描述在C#中线程同步的方法。线程的基本概念网上资料也很多就不再赘述了。直接接入主题，在多线程开发的应用中，线程同步是不可避免的。在.Net框架中，实现线程同步主要通过以下的几种方式来实现，在MSDN的线程指南中已经讲了几种，本文结合作者实际中用到的方式一起说明一下。 1. 维护自由锁(InterLocked)实现同步 2. 监视器（Monitor）和互斥锁（lock） 3. 读写锁
Interlocked 类
小发发吖的博客
08-31 494
为多个线程共享的变量提供原子操作。 "原子操作(atomic operation)是不需要synchronized"，这是Java多线程编程的老生常谈了。所谓原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束，中间不会有任何 context switch （切[1]  换到另一个线程）。 Add(Int64, Int64) 对
.net中的System.Threading.Interlocked类可以为多个线程共享的变量提供原子操作
Kevin yan的专栏
09-18 1304
.net中的System.Threading命名空间的Interlocked类可以为多个线程共享的变量提供原子操作。       经验显示，那些需要在多线程下被保护的资源通常是整型的，而这些被共享的整型值最常见的操作就是增加、减少。Interlocked类提供了一个专门的机制用于完成这些特定的操作。       下面的例子是一个没有使用Interlocked类的操作：      
VB.net学习笔记（二十八）线程同步下
白话魔法师
06-11 6415
3、ReaderWriterLock 类     ReaderWriterLock定义了实现单写程序和多写程序语义的锁。ReaderWriterLock类中4个主要的方法 • AcquireReacJerLock()：获得-个读程序锁，超时值使用一个整数或一个 TimeSpan。 • AcquireWiiterLock()：     获得一个写程序锁，超时值使用一个整数或一个 TimeSpa
C#中使用Interlocked进行原子操作的技巧
09-01
C#中的`Interlocked`类提供了诸如`Increment`、`Decrement`、`Exchange`、`CompareExchange`等方法，它们都保证了操作的原子性。以`Interlocked.Increment(ref value)`为例，这个方法会增加给定引用的变量的值并返回...
.NET中保证线程安全的高级方法Interlocked类使用介绍
09-04
在高并发场景下，Interlocked类提供的这些原子操作方法相比使用锁（如Monitor或Mutex）通常更高效，因为它们直接依赖于底层硬件的原语，减少了上下文切换和锁竞争的可能性。然而，值得注意的是，虽然Interlocked类能...
C# Interlocked 原子操作
oopxiajun博客专栏
06-07 1532
我对Interlocked原子操作的理解是：如同一桌人喝一碗汤，汤碗里面有一个公用的勺子，不能多个人同时使这把公用的勺子舀汤， 当有人想喝汤时（或者服务员想要加汤时），就得先拿到勺子，其他人就没法喝汤（或者添汤）。只有喝汤的人（添汤的人）用完勺子放回汤碗后，其他人才能继续使用勺子喝汤（添汤）。
使用 Visual Basic .NET 进行多线程编程
weixin_30607659的博客
04-29 1431
摘要：.NET 框架提供了新的类，可以方便地创建多线程应用程序。本文介绍如何使用 Visual Basic® .NET 的多线程编程技术来开发效率更高、响应速度更快的应用程序。 目录 简介 多线程处理的优点 创建新线程 同步线程 线程计时器 取消任务 总...
System.Math.Min(System.Threading.Interlocked.Increment(i), i - 1)的问题
zhlufeng的专栏
12-28 951
今天在学习一段VB.net的代码时看到了这样的语句System.Math.Min(System.Threading.Interlocked.Increment(i), i - 1) 百思不得其解，在Google上搜了一把，发现这段语句是C#程序转为VB.net时自动生成的。由于在C#程序中使用了诸如 i++之类得得语句，所以为了防止转换后的VB.net程序传递错误的值，就将源程序中的语句自动转
VB.NET编程多线程
wl58796351的专栏
08-31 1973
VB.NET编程多线程   http://wl58028766.blog.163.com/blogBackendManage.do?fromnewcenter#m=0 2010-12-01 14:44:50|  分类：默认分类 |  标签：|字号大中小 订阅
c#之线程同步浅析（1）-----轻量级同步Interlocked
热门推荐
kkfdsa132的专栏
04-11 2万+
        在c#里面，实现线程同步方法有很多种。我了解到的至少有8种。这里先讲下，一种比较简单的同步方法-------轻量级同步Interlock。        为什么说它是轻量级呢？因为它仅对整形数据（即int类型，long也行）进行同步。如果你学过操作系统里面的PV操作（即信号量），那么你对它已经了解了一般。它实现的正是如同信号量的功能。下面是它提供的方法：       
【Windows】线程漫谈——.NET线程同步之Interlocked和ReadWrite锁
weixin_30613343的博客
07-24 168
摘要: 本系列意在记录Windwos线程的相关知识点，包括线程基础、线程调度、线程同步、TLS、线程池等。 这篇来说说静态的Interlocked类和ReadWrite锁 .NET中的Interlocked Interlocked的系列方法提供了对简单类型的原子操作（不会被打断的操作），因此这也是一种多线程共享变量，防止冲突争用的方法。 比如下面的方法作用是以原子的方式递增整数i： in...
VB.net学习笔记（二十七）线程同步上
白话魔法师
06-11 9578
X夫妇二人试图同时从同一账户(总额1000)中支取1000。由于余额有1000，夫妇各自都满足条件，于是银行共支付2000。结果是银行亏了1000元。这种两个或更多线程试图在同一时刻访问同一资源来修改其状态，并产生不良后果的情况被称做竞争条件。                                                  为避免竞争条件，需要使Withdraw()方法具有线
VB.NET多线程编程技术
action20的专栏
08-13 1764
传统的Visual Basic开发人员已经建立了同步应用程序，在这些程序中事务按顺序执行。尽管由于多个事务多多少少地同时运行使多线程应用程序效率更高，但是使用先前版本的Visual Basic很难建立这类程序。 　　多线程程序是可行的，因为操作系统是多任务的，它有模拟同一时刻运行多个应用程序的能力。尽管多数个人计算机只有一个处理器，但是现在的操作系统还是通过在多个执行代码片断之间划分处理
线程同步（使用Interlocked类）
陈言必行 -- Unity游戏开发领域优质博主
10-13 1484
通过System.Threading命名空间的Interlocked类控制计数器，从而实现进程 的同步。Iterlocked类的部分方法如下表： 示例，，同时开启两个线程，一个写入数据，一个读出数据，，， 代码如下：（但是运行结果却不是我们想象的那样）using System; using System.Threading;namespace 线程同步 { class Program
自由锁(InterLocked)
yousuf007的专栏
10-13 835
http://blog.sina.com.cn/s/blog_a8c00bbb01016gty.html 在大多数计算机上，增加变量操作不是一个原子操作，需要执行下列步骤： 1.       将实例变量中的值加载到寄存器中。 2.       增加或减少该值。 3.       在实例变量中存储该值。   在多线程环境下，线程会在执行完前两个
C# 使用Interlocked类提供的原子操作方法
最新发布
10-28
C# 中的 `System.Threading.Interlocked` 类提供了一组用于在多线程环境中进行原子操作的方法。原子操作是指不会被其他线程中断的操作，保证了操作结果的一致性和完整性。在单个处理器核心上，这些操作通常是不可分割的，但是在多核环境下，它们会尽可能保持低级锁（Lock-free），提高性能。 以下是一些常见的 `Interlocked` 方法示例： 1. **`Interlocked.Add`**：对一个整数类型的变量进行加法操作，并确保操作是原子的。这对于在多线程环境中累加计数非常有用，比如递增一个计数器： ```csharp int counter = 0; Interlocked.Add(ref counter, 1); // 线程安全地将counter加1 ``` 2. **`Interlocked.Exchange`**：原子地交换两个变量的值，常用于互斥锁（Mutex）等场景： ```csharp bool lockTaken; ref bool currentLock = ref Interlocked.Exchange(ref myLock, true); if (!currentLock) { // Acquired the lock } ``` 3. **`Interlocked.Decrement`** 和 **`Interlocked.Increment`**：分别用于减一和加一操作，同样保证了原子性。 4. **`CompareExchange`**：比较并替换值，只有当目标值等于预期值时才进行替换，适用于读取-条件-写入（Read-Modify-Write）的场景。 使用 `Interlocked` 进行操作时，可以避免不必要的上下文切换和竞态条件，提高程序的性能。然而，它并不是所有情况下的万能解，对于复杂的并发问题，可能还需要配合其他的并发控制机制如 `Monitor` 或者 `lock` 语句。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

专注VB编程开发20年

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值