Кога записите/четенията засягат основната памет?

Volatile и Interlocked вече бяха споменати, вие поискахте примитиви, едно допълнение към списъка е да използвате Thread.MemoryBarrier() преди вашите записи или четения. Това гарантира, че няма да се извършва пренареждане на записи и четения в паметта.

Това прави "на ръка" това, което lock, Interlocked и volatile могат да правят автоматично през повечето време. Можете да използвате това като пълна замяна на всяка друга техника, но това е може би най-трудният път за пътуване и така казва MSDN:

"Трудно е да се изграждат правилни многонишкови програми с помощта на MemoryBarrier. За повечето цели операторът за заключване на C#, операторът SyncLock на Visual Basic и методите на класа Monitor предоставят по-лесни и по-малко склонни към грешки начини за синхронизиране на достъпа до паметта . Препоръчваме ви да ги използвате вместо MemoryBarrier. "

Как да използвате MemoryBarrier

Много добър пример са реализациите на VolatileRead и VolatileWrite, които и двете вътрешно използват MemoryBarrier. Основното правило, което трябва да следвате, е: когато четете променлива, поставете бариера на паметта след четенето. Когато пишете стойността, бариерата на паметта трябва да е преди записа.

В случай, че се съмнявате дали това е по-малко ефективно от lock, помислете, че заключването не е нищо повече от "пълно ограждане", тъй като поставя бариера на паметта преди и след кодовия блок (игнорирайки Monitor за момент). Този принцип е добре обяснен в тази отлична окончателна статия за нишки, заключване, летливи и бариери на паметта от Албахари.

От рефлектор:

public static void VolatileWrite(ref byte address, byte value)
{
    MemoryBarrier();
    address = value;
}

public static byte VolatileRead(ref byte address)
{
    byte num = address;
    MemoryBarrier();
    return num;
}

Ако искате да сте сигурни, че е написан навреме и в ред, тогава го маркирайте като volatile или (с повече болка) използвайте Thread.VolatileRead / Thread.VolatileWrite (не е привлекателна опция и лесно може да се пропусне, правейки я безполезна).

volatile int m_foo;

Може също да искате да разгледате заключването (Monitor) или Interlocked, което ще постигне същия ефект стига да се използва същият подход от всички достъпи (т.е. всички lock или всички Interlocked и т.н.).

Докато не използвате никаква синхронизация, нямате гаранция, че нишка, работеща на един процесор, вижда промените, направени от друга нишка, работеща на друг процесор. Това е така, защото стойността може да се кешира в кеш паметта на процесора или в регистър на процесора.

Следователно трябва или да маркирате променливата като непостоянна. Това ще създаде релация „Случва се преди“ между четене и запис.

Това не е проблем с кеша на процесора. Записите обикновено са преминаващи (записите отиват както в кеша, така и в основната памет) и всички четения имат достъп до кеша. Но има много други кешове по пътя (език за програмиране, библиотеки, операционна система, I/O буфери и т.н.). Компилаторът може също така да избере да запази променлива в регистър на процесора и никога да не я записва в основната памет (за това е предназначен операторът volatile, избягвайте съхраняването на стойност в регистъра, когато може да бъде I/O, картографиран в паметта).

Ако имате множество процеси или множество нишки и синхронизирането е проблем, трябва да го направите изрично, има много начини да го направите в зависимост от случая на употреба.

За програма с една нишка не се интересувайте, компилаторът ще направи това, което трябва и чете ще има достъп до написаното.