c# - 这个 "Int64"代理是原子的吗？

Question

我将创建一个必须是原子的“长”(Int64) 代理项，因此它在并发应用程序中的副本本质上是安全的。我不能使用 Int32，因为它的范围太短。

我知道只要涉及到的数据可以放在一个双字(32位)中，就应该保证原子性。无论操作系统是 32 位还是 64 位。

现在，考虑以下“长”代理项...

注意:我省略了几个方法，因为我不需要它们。在这种情况下，我只需要与真正的 long 进行基本转换。

public struct SafeLong
    : IConvertible
{
    public SafeLong(long value)
    {
        unchecked
        {
            var arg = (ulong)value;
            this._data = new byte[]
            {
                (byte)arg,
                (byte)(arg >> 8),
                (byte)(arg >> 16),
                (byte)(arg >> 24),
                (byte)(arg >> 32),
                (byte)(arg >> 40),
                (byte)(arg >> 48),
                (byte)(arg >> 56),
            };
        }
    }



    private byte[] _data;



    private long Value
    {
        get
        {
            unchecked
            {
                var lo =
                    this._data[0] |
                    this._data[1] << 8 |
                    this._data[2] << 16 |
                    this._data[3] << 24;

                var hi = 
                    this._data[4] |
                    this._data[5] << 8 |
                    this._data[6] << 16 |
                    this._data[7] << 24;

                return (long)((uint)lo | (ulong)(uint)hi << 32);
            }
        }
    }



    public static implicit operator long(SafeLong value)
    {
        return value.Value;  // implicit conversion
    }



    public static explicit operator SafeLong(long value)
    {
        return new SafeLong(value);  // explicit conversion
    }


    #region IConvertible implementation

    public TypeCode GetTypeCode()
    {
        return Type.GetTypeCode(typeof(SafeLong));
    }

    public object ToType(Type conversionType, IFormatProvider provider)
    {
        return Convert.ChangeType(this.Value, conversionType);
    }

    public long ToInt64(IFormatProvider provider)
    {
        return this.Value;
    }

    // ... OMISSIS (not implemented) ...

    #endregion
}

好吧，它似乎和我预期的一样完美。

这是一个小测试:

class Program
{
    static void Main(string[] args)
    {
        var sla = (SafeLong)12345678987654321L;
        var la = (long)sla;
        Console.WriteLine(la);

        var slb = (SafeLong)(-998877665544332211L);
        var lb = (long)slb;
        Console.WriteLine(lb);

        Console.WriteLine(Marshal.SizeOf(typeof(SafeLong)));
        Console.WriteLine(Marshal.SizeOf(sla));
        Console.WriteLine(Marshal.SizeOf(slb));

        long lc = new SafeLong(556677);
        var slc = slb;
        Console.WriteLine(slc);
        slc = (SafeLong)lc;
        Console.WriteLine(slc);
        Console.WriteLine(slb);

        Console.Write("Press any key...");
        Console.ReadKey();
    }
}

SizeOf 函数总是产生 4 个字节作为我的代理项的大小。这个值是否保证了 SafeLong 到 SafeLong 副本的原子性，或者这 4 个字节应该被解释为“真正的物理双字”？

无论长 <--> SafeLong 的非原子性如何:它将被包含在一个安全的上下文中。

非常感谢。

Answer 1

你是对的，因为这是原子的，但天哪，这是一个简单问题的复杂解决方案。如果您想要一个具有 long 值但使用原子引用的结构，只需将 long 框起来!事实上，如果你这样做，那么你可以创建任何结构类型的原子版本，所以让我们这样做:

public struct SafeThing<T> where T : struct
{
    private object boxedThing;

    public SafeThing(T value)
    {
        boxedThing = value;
    }

    public T Value { get { return boxedThing == null ? default(T) : (T)boxedThing; } }

    public static implicit operator T(SafeThing<T> value)
    {
        return value.Value; 
    }

    public static implicit operator SafeThing<T>(T value)
    {
        return new SafeThing(value); 
    }
}

你就完成了。你为什么要用数组来做这些乱七八糟的事情？

此外，我注意到在您的实现中，您的显式/隐式转换倒退了。只有在无损且不抛出的情况下，转换才应该是隐式的。从 SafeLong 到 long 的隐式转换可能会抛出异常，因此它不应该是隐式的。您从 long 到 SafeLong 的显式转换不会抛出并且是无损的，因此如果您愿意，它可以是隐式的。如您所见，我通过使两个方向都无损且不抛出来解决了我的实现中的问题，因此它们都是隐式的。

请注意，这个结构本质上是一个围绕装箱值的强类型包装器；如果泛型类型在 CLR 的第一个版本中可用，那么毫无疑问，盒装值类型将使用类似这样的某种类型来实现，就像可空值类型类似地由特殊泛型类型实现一样。

The SizeOf function yields always 4 bytes as the size of my surrogate. Does this value guarantees the atomicity of a copy SafeLong-to-SafeLong?

好吧，是的，不是。

首先，“SizeOf”方法不给出内存中结构的大小；它给出结构的大小当它跨托管/非托管边界持久化时。这不一定与托管内存中结构的大小相同；它经常是相同的，但不保证是相同的。如果您想知道托管内存中结构的大小，则需要打开“不安全”模式并使用“sizeof”运算符。

实际上，大小为 4 的结构的副本始终是原子的，前提是它被复制到与四字节边界对齐的位置。 语言规范 不保证任何四字节结构将被自动复制，但事实上在我们的实现中确实如此。

在您的特定情况下，这四个字节是对数组的引用；语言规范确实保证引用总是被自动复制。