使用 volatile 关键字和 lock 语句

Question

我在应用程序中收到“对易失性字段的引用不会被视为易失性”警告。我明白为什么。

作为一个简单的例子，即使我仍然收到警告，下面的代码是否会使问题线程安全？

private volatile int myVal = 10;
private int myNonVolatileNumber = 50;
private static readonly object lockObject = new object();

private void ChangeValue(ref int Value)
{
  lock (lockObject)
  {
    Value = 0;
  }
}

private void MyMethod()
{
  ChangeValue(ref myVal); //Warning here
  ChangeValue(ref myNonVolatileNumber); //no warning
}

Answer 1

锁定会强制两侧的内存屏障，所以是的，您的示例是线程安全的。

Answer 2

您几乎自己回答：

ChangeValue(ref myVal); //Warning here
ChangeValue(ref myNonVolatileNumber); //no warning

编译后的 ChangeValue() 只有 1 个副本，其中的代码应该实现“易失性”行为。但编译器（Jitter）在编译时无法预测所有调用。唯一的选择是将每个 ref 参数视为易失性的，这将是非常低效的。

但请参阅@Steven 的评论，易失性 毫无用处，应该避免。

Answer 3

可能在您使用过的地方不需要使用 volatile 关键字。

这个问题回答了所有应该使用 volatile 关键字的地方：

什么时候应该在 C# 中使用 volatile 关键字？

Answer 4

会有什么问题

private int val = 10;
private var valLock = new object();
private int nonVolatileNumber = 50;
private var nonVolatileNumberLock = new object();

public int Value
{
    get { lock(valLock) return val; }
    set { lock(valLock) val = value; }
}

public int NonVolatileNumber
{
    get { lock(nonVolatileNumberLock) return nonVolatileNumber; }
    set { lock(nonVolatileNumberLock) nonVolatileNumber = value; }
}

，这里唯一的风险是后续代码访问该属性的私有成员。

对于 32 位整数，甚至 64 位系统上的 64 位整数，由于读取是原子的，因此您可以使用 Interlocked 像这样的类...

private int val = 10;

public int Value
{
    get { return val; }
    set { Interlocked.Exchange(ref val, value); }
}

或者在更复杂的类型的情况下，您可以使用 ReadWriterLockSlim ...

private SomeStructure complex;
private var complexLock = new ReadWriterLockSlim();

public SomeStructure Complex
{
    get
    {
        complexLock.EnterReadLock();
        try
        {
            return complex;
        }
        finally
        {
            complexLock.ExitReadlock();
        }
    }
    set
    {
        complexLock.EnterWriteLock();
        try
        {
            return complex;
        }
        finally
        {
            complexLock.ExitWritelock();
        }
    }
}

这比标准锁更好，因为它允许多个同时读取。