Может ли DateTime разрываться в 64-битной среде?

В параметре С# значение переменной равно атомному, если его размер не превышает native int (т.е. 4 байта в 32-битной среде выполнения и 8 байтов на 64-битной). В 64-битной среде, которая включает в себя все типы ссылок и большинство встроенных типов значений (byte, short, int, long и т.д.).

Установка большего значения не является атомарной и может вызвать разрывы, когда обновляется только часть памяти.

DateTime - это структура, которая включает только одно поле ulong, содержащее все его данные (Ticks и DateTimeKind) и ulong само по себе является атомарным в 64-битной среде.

Означает ли это, что DateTime является атомарным? Или может ли следующий код привести к разрыву в какой-то момент?

static DateTime _value;
static void Main()
{
    for (int i = 0; i < 10; i++)
    {
        new Thread(_ =>
        {
            var random = new Random();
            while (true)
            {
                _value = new DateTime((long)random.Next() << 30 | (long)random.Next());
            }
        }).Start();
    }

    Console.ReadLine();
}

Ответ 1

Из спецификация ECMA раздел "I.12.6.6 Атомные чтения и записи"

Соответствующий CLI должен гарантировать, что доступ для чтения и записи к правильно выровненным ячейкам памяти не превышает размер родного слова (размер типа native int) является атомарным (см. п. 1.1.6.2), когда все обращения к записи к местоположению одинакового размера. Атомные записи не должны изменять никаких битов, кроме написанных. Если для изменения поведения по умолчанию не используется явное управление компоновкой (см. Раздел II ( "Управление макетом экземпляра" ), элементы данных, не превышающие размер естественного слова (размер native int), должны быть правильно выровнены. Ссылки на объекты должны обрабатываться так, как если бы они были сохранены в размере родного слова.

A native int является IntPtr в С#.

Пока sizeof(IntPtr) >= sizeof(DateTime) истинно для среды выполнения (aka: running as 64 bit), и они не изменяют внутреннюю структуру, чтобы быть явным макетом с несогласованными байтами вместо [StructLayout(LayoutKind.Auto)], который он имеет в настоящее время, то чтение и запись структуры DateTime (или любой другой структуры, которая следует этим правилам) гарантированно будут атомарными по спецификации ECMA.

Вы можете убедиться, что, выполнив следующий код в 64-разрядной среде:

public unsafe static void Main()
{
    Console.WriteLine(sizeof(DateTime)); // Outputs 8
    Console.WriteLine(sizeof(IntPtr)); // Outputs 8
    Console.WriteLine(sizeof(ulong)); // Outputs 8
}

Ответ 2

Выполняя некоторые тесты и основываясь на ответе выше, вполне можно сказать, что сегодня он атомный.

Я написал тест, чтобы проверить, сколько слез может быть найдено во время X-итераций по N потокам для Int64, DateTime и 3 пользовательских структур из 128, 192 и 256 размеров - ни один из них не испорчен в StructLayout.

Тест состоит из:

Добавление набора значений в массив, чтобы они были известны.
Настройка одного потока для каждой позиции массива, этот поток присваивает значение из массива общей переменной.
Настройка того же количества потоков (array.length) для чтения из этой общей переменной в локальную.
Проверьте, содержится ли этот локал в исходном массиве.

Результаты на моем компьютере следующие: Core i7-4500U, Windows 10 x64,.NET 4.6, Release без отладки, Платформа: x64 с оптимизацией кода):

-------------- Trying to Tear --------------
Running: 64bits
Max Threads: 30
Max Reruns: 10
Iterations per Thread: 20000
--------------------------------------------
----- Tears ------ | -------- Size ---------
          0             Int64 (64bits)
          0             DateTime (64bits)
         23             Struct128 (128bits)
         87             Struct192 (192bits)
         43             Struct256 (256bits)
----- Tears ------ | -------- Size ---------
          0             Int64 (64bits)
          0             DateTime (64bits)
         44             Struct128 (128bits)
         59             Struct192 (192bits)
         52             Struct256 (256bits)
----- Tears ------ | -------- Size ---------
          0             Int64 (64bits)
          0             DateTime (64bits)
         26             Struct128 (128bits)
         53             Struct192 (192bits)
         45             Struct256 (256bits)
----- Tears ------ | -------- Size ---------
          0             Int64 (64bits)
          0             DateTime (64bits)
         46             Struct128 (128bits)
         57             Struct192 (192bits)
         56             Struct256 (256bits)
------------------- End --------------------

Код для теста можно найти здесь: https://gist.github.com/Flash3001/da5bd3ca800f674082dd8030ef70cf4e

Ответ 3

Из спецификации языка С#.

5.5 Атоматичность переменных ссылок Считывание и запись следующих типов данных являются атомарными: bool, char, byte, sbyte, short, ushort, uint, int, float и reference. Кроме того, чтение и запись перечисления типы с базовым типом в предыдущем списке также являются атомарными. Читает и пишет другие типы, включая long, ulong, double и десятичные, а также пользовательские типы не гарантируются. атомное. Помимо библиотечных функций, предназначенных для этой цели, нет гарантии атомного чтения-модификации-записи, например, в случае прироста или уменьшения.