Блокується і мінливий

У мене є змінна, яку я використовую для представлення стану. Його можна читати та записувати з декількох потоків.

Я використовую Interlocked.Exchangeі, Interlocked.CompareExchangeщоб змінити це. Однак я читаю це з декількох потоків.

Я знаю, що це volatileможе бути використано для переконання, що змінна не кешована локально, а завжди читає безпосередньо з пам'яті.

Однак якщо я встановлюю змінну на volatile, тоді вона генерує попередження про використання volatile і передачу за допомогою ref до методів Interlocked.

Я хочу переконатися, що кожен потік читає останнє значення змінної, а не якусь кешовану версію, але я не можу використовувати volatile.

Є, Interlocked.Read але це для 64-розрядних типів, і він недоступний на компактній платформі. У документації до нього сказано, що він не потрібен для 32-бітових типів, оскільки вони вже виконуються за одну операцію.

В Інтернеті є заяви, що вам не потрібні нестабільні, якщо ви використовуєте взаємоблоковані методи для всього свого доступу. Однак ви не можете прочитати 32-бітну змінну за допомогою методів Interlocked, тому ви не можете використовувати методи Interlocked для всього свого доступу.

Чи є якийсь спосіб здійснити безпечне читання та запис моєї змінної без використання блокування?

Ви можете сміливо нехтувати цим попередженням, коли використовуєте Interlocked.Xxxфункції (див. Це запитання ), оскільки вони завжди виконують нестабільні операції. Отже, volatileзмінна цілком нормальна для спільного стану. Якщо ви хочете позбутися застереження будь-якою ціною, ви насправді можете виконати блоковане читання Interlocked.CompareExchange (ref counter, 0, 0).

Редагувати: Насправді вам потрібна volatileваша змінна стану лише в тому випадку, якщо ви збираєтеся писати на неї безпосередньо (тобто не використовуючи Interlocked.Xxx). Як згадано jerryjvl , читання змінної, оновленої блокованою (або нестабільною) операцією, використовуватиме найновіше значення.

Заблоковані операції та летючі властивості насправді не повинні використовуватися одночасно. Причиною отримання попередження є те, що воно (майже?) Завжди вказує на те, що ви неправильно зрозуміли, що робите.

Надто спрощення та перефразування:
volatileвказує на те, що кожна операція читання потребує повторного читання з пам'яті, оскільки можуть бути інші потоки, що оновлюють змінну. При застосуванні до поля, яке можна читати / писати атомно за допомогою архітектури, на якій ви працюєте, це повинно бути все, що вам потрібно зробити, якщо ви не використовуєте long / ulong, більшість інших типів можна читати / писати атомно.

Коли поле не позначене летким, ви можете використовувати Interlockedоперації, щоб зробити подібну гарантію, оскільки це спричиняє очищення кеш-пам’яті, щоб оновлення було видимим для всіх інших процесорів ... це має ту перевагу, що ви ставите накладні витрати оновлення, а не прочитане.

Який із цих двох підходів буде найкращим, залежить від того, що саме ви робите. І це пояснення є грубим надмірним спрощенням. Але з цього повинно бути зрозуміло, що робити обидва одночасно безглуздо.