易失性日期时间

Question

由于DateTime不能声明为易失性，这是对的吗？

private DateTime _time;
public DateTime Time
{
    get
    {
        Thread.MemoryBarrier();
        return _time;
    }
    set
    {
        _time = value;
        Thread.MemoryBarrier();
    }
}

该属性可以从不同的线程访问，因此我想确保它们始终获得最新版本，而不使用争用（lock）。

编辑：

• 我有一组难以创建的项目，每个项目都有一个名为 CreationTime 的 DateTime 属性，指示该项目的创建时间。它被初始化为DateTime.UtcNow。
• 每次访问某个项目时，该属性都会更新为 DateTime.UtcNow。
• 有一个线程，在线程计时器中及时执行，检查 if (DateTime.UtcNow + 1 hour) > > item.CreationTime，如果为 true，则删除该项目。

我想确保当“删除线程”进入集合时，所有项目都有其最新的“上次访问”DateTime，这样我就可以避免仅仅因为缓存保留而再次创建该项目几毫秒的值。 ：D

Answer 1

恰恰。

但是，你还有另一种选择。将时间存储为 Int64 刻度计数，并使用 InterlockedExchange 进行设置。然后，线程可以使用 Int64 构造自己的 DateTime a> 构造函数，没有争用，也没有锁。

编辑：

鉴于您提供了更多信息，现在更容易提供示例。

public class Cache
{
    class CacheEntry
    {
        private Int64 m_Touched;

        public CacheEntry()
        {
            Touch();
        }

        public void Touch() 
        {
            System.Threading.Interlocked.Exchange(ref m_Touched, DateTime.Now.Ticks);
        }

        public DateTime Touched
        {
            get
            {
                return new DateTime(Interlocked.Read(ref m_Touched));
            }
        }
    } // eo class CacheEntry
} // eo class Cache

Answer 2

您的代码不是线程安全的，因为 DateTime 的分配不能保证是原子的。一般来说，32 位以下的整数赋值是原子的，但 64 位的整数则不必是原子的。

您可能可以将 Interlocked.Exchange 与 DateTime 的刻度一起使用，因为它可以自动存储 Int64。

但如果您切换到刻度，您需要知道只有 62 位用于刻度，2 位用于类型。所以你不会失去那种。

即使你使 getter 和 setter 原子化并成为线程安全的，我也不确定这是否足够。由于获取器返回的时间和您实际使用所获得的时间之间的时间可能会发生变化。所以你的时间总是会过时。

Answer 3

这是不可能的 - 您需要使用 lock 或 Monitor 类来同步对该字段的访问。

这是因为 DateTime 是一种值类型 - 一种结构。

来自 MSDN - 易失性（C# 参考）：

volatile 关键字可以应用于以下类型的字段：

• 参考类型。
• 指针类型（在不安全的上下文中）。请注意，虽然指针本身可以是易失性的，但它指向的对象却不能。换句话说，您不能声明“指向 volatile 的指针”。
• sbyte、byte、short、ushort、int、uint、char、float 和 bool 等类型。
• 具有以下基本类型之一的枚举类型：byte、sbyte、short、ushort、int 或 uint。
• 已知为引用类型的通用类型参数。
• IntPtr 和 UIntPtr。

---

正如其他人提到的，您可以使用 Ticks 来跟踪时间。

Answer 4

.NET Core 包含 不安全.As 方法，它允许对 DateTime 变量执行易失性读/写，如下所示：

public static DateTime VolatileRead(ref DateTime location)
{
    ref ulong unsafeLocation = ref Unsafe.As<DateTime, ulong>(ref location);
    ulong result = Volatile.Read(ref unsafeLocation);
    return Unsafe.As<ulong, DateTime>(ref result);
}

public static void VolatileWrite(ref DateTime location, DateTime value)
{
    ref ulong unsafeLocation = ref Unsafe.As<DateTime, ulong>(ref location);
    ref ulong unsafeValue = ref Unsafe.As<DateTime, ulong>(ref value);
    Volatile.Write(ref unsafeLocation, unsafeValue);
}

用法：

DateTime latest = VolatileRead(ref _dateTimeField);

VolatileWrite(ref _dateTimeField, newDateTime);

这是一个 hack，因为它取决于 DateTime 类型永远由 ulong 字段支持。根据具体情况，自行判断使用它是否合适/安全/谨慎。

来自 源代码：

private readonly ulong _dateData;

Answer 5

这行得通吗？

public class VolatileDateTime
{
    private readonly DateTime _datetime;
    public VolatileDateTime(DateTime datetime)
    {
        _datetime = datetime;
    }

    public DateTime Value { get => _datetime; }
}

……

volatile VolatileDateTime vDateTime = new VolatileDateTime(DateTime.Now)

​

if (vDateTime.Value > somedatetime)
    dosomething();