当前位置：文江博客话题详情

何时使用“易失性”？或“Thread.MemoryBarrier()”在线程安全锁定代码中？ (C#)

发布于 2024-08-03 02:43:00 字数 57 浏览 4 评论 0原文

我什么时候应该使用 volatile/Thread.MemoryBarrier() 来保证线程安全？

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

人事已非 2024-08-10 02:43:00

当您想要跨线程访问变量而不加锁时，可以使用volatile/Thread.MemoryBarrier()。

原子变量（例如 int）总是一次读取和写入整个变量。这意味着您永远不会在另一个线程更改该值之前获得该值的一半，也不会在该值更改后获得另一半。因此，您可以安全地在不同线程中读取和写入该值，而无需同步。

但是，编译器可能会优化一些读取和写入操作，您可以使用 volatile 关键字来阻止这些操作。例如，如果您有这样的循环：

sum = 0;
foreach (int value in list) {
   sum += value;
}

编译器实际上可能在处理器寄存器中进行计算，并且仅在循环后将值写入 sum 变量。如果将 sum 变量设为 易失性，编译器将生成针对每次更改读取和写入该变量的代码，以便其值在整个循环中保持最新。

You use volatile/Thread.MemoryBarrier() when you want to access a variable across threads without locking.

Variables that are atomic, like an int for example, are always read and written whole at once. That means that you will never get half of the value before another thread changes it and the other half after it has changed. Because of that you can safely read and write the value in different threads without syncronising.

However, the compiler may optimize away some reads and writes, which you prevent with the volatile keyword. If you for example have a loop like this:

sum = 0;
foreach (int value in list) {
   sum += value;
}

The compiler may actually do the calculations in a processor register and only write the value to the sum variable after the loop. If you make the sum variable volatile, the compiler will generate code that reads and writes the variable for every change, so that it's value is up to date throughout the loop.

回复收藏 0 原文

海拔太高太耀眼 2024-08-10 02:43:00

有什么问题吗

private static readonly object syncObj = new object();
private static int counter;

public static int NextValue()
{
    lock (syncObj)
    {
        return counter++;
    }
}

？

这会为您完成所有必要的锁定、内存屏障等。它比任何基于 volatile 和 Thread.MemoryBarrier() 的自定义同步代码更易于理解且更具可读性。

编辑

我想不出使用易失性或Thread.MemoryBarrier()的场景。例如，

private static volatile int counter;

public static int NextValue()
{
    return counter++;
}

不等价于上面的代码，并且不线程安全（易失性不会使++ 神奇地变成线程安全的）。

在这样的情况下：（

private static volatile bool done;

void Thread1()
{
    while (!done)
    {
        // do work
    }
}

void Thread2()
{
    // do work
    done = true;
}

应该有效）我会使用 ManualResetEvent 在 Thread2 完成时发出信号。

What's wrong with

private static readonly object syncObj = new object();
private static int counter;

public static int NextValue()
{
    lock (syncObj)
    {
        return counter++;
    }
}

This does all necessary locking, memory barriers, etc. for you. It's well understood and more readable than any custom synchronization code based on volatile and Thread.MemoryBarrier().

EDIT

I can't think of a scenario in which I'd use volatile or Thread.MemoryBarrier(). For example

private static volatile int counter;

public static int NextValue()
{
    return counter++;
}

is not equivalent to the code above and is not thread-safe (volatile doesn't make ++ magically become thread-safe).

In a case like this:

private static volatile bool done;

void Thread1()
{
    while (!done)
    {
        // do work
    }
}

void Thread2()
{
    // do work
    done = true;
}

(which should work) I'd use a ManualResetEvent to signal when Thread2 is done.

回复收藏 0 原文