c# - 鉴于 doubles 不能用于 volatile 字段，这是一个安全的选择吗？

Question

鉴于 double 不能用于 volatile 字段，这是一个安全的替代方案吗？或者它会导致空指针异常。

public sealed class DoubleStorage
{
    public readonly double Value;

    public DoubleStorage(double value)
    {
        this.Value = value;
    }

    public static readonly DoubleStorage Zero = new DoubleStorage(0);
}

public sealed class Val
{
    private volatile DoubleStorage boostResult = DoubleStorage.Zero;

    public double ThreadSafeDouble
    {
        set
        {
            //is this assignment attomic?
            boostResult = new DoubleStorage(value);
        }
        get
        {
            //or could this give null pointer exception?
            return boostResult.Value;
        }
    }
}

Answer 1

是的，访问引用是原子的。

但是，你可以只装箱子，你不必创建一个类来封装它:

public sealed class Val {

  private volatile object boostResult = 0.0;

  public double ThreadSafeDouble {
    set {
        boostResult = value;
    }
    get {
        return (double)boostResult;
    }
  }
}

将 double 赋值给变量会创建一个包含 double 的对象，然后将引用赋值给变量。由于引用分配是原子的，因此它是线程安全的。

当对 double 进行拆箱时，从变量中读取引用是原子的，因此它是线程安全的，尽管读取 double 不是原子的。由于 boxed double 是不可变的，因此特定的 boxed 值永远不会改变。

---

或者通用版本呢:

public sealed class ThreadSafe<T> where T : struct {

  private volatile object _value;

  public ThreadSafe() {
    Value = default(T);
  }

  public ThreadSafe(T value) {
    Value = value;
  }

  public T Value {
    get {
      return (T)_value;
    }
    set {
      _value = value;
    }
  }

}