อ่านของเขตระเหยมีความหมายซื้อ ซึ่งหมายความว่าจะรับประกันได้ว่าหน่วยความจำที่อ่านจากตัวแปรระเหยจะเกิดขึ้นก่อนที่หน่วยความจำต่อไปนี้จะอ่าน จะบล็อกคอมไพเลอร์ไม่ให้ทำการเรียงลำดับใหม่และหากฮาร์ดแวร์ต้องการ (สั่ง CPU อย่างอ่อน) มันจะใช้คำสั่งพิเศษเพื่อให้ฮาร์ดแวร์ทำการล้างการอ่านใด ๆ ที่เกิดขึ้นหลังจากการอ่านระเหย แต่เริ่มต้นอย่างเร็วหรือ CPU อาจ ป้องกันไม่ให้มีการออก แต่เนิ่นๆตั้งแต่แรกโดยป้องกันการโหลดที่เกิดจากการเก็งกำไรระหว่างปัญหาของการรับโหลดและการปลด
การเขียนฟิลด์ที่ระเหยได้มีการปล่อยซีแมนทิกส์ ซึ่งหมายความว่าจะรับประกันได้ว่าหน่วยความจำใด ๆ ที่เขียนลงในตัวแปรระเหยจะรับประกันว่าจะล่าช้าจนกว่าหน่วยความจำก่อนหน้านี้ทั้งหมดจะปรากฏแก่โปรเซสเซอร์อื่น ๆ
ลองพิจารณาตัวอย่างต่อไปนี้:
something.foo = new Thing();
ถ้าfooเป็นตัวแปรสมาชิกในคลาสและ CPU อื่นสามารถเข้าถึงอินสแตนซ์ของวัตถุที่อ้างอิงโดยsomethingพวกเขาอาจเห็นการfooเปลี่ยนแปลงค่าก่อนที่หน่วยความจำเขียนในตัวThingสร้างจะมองเห็นได้ทั่วโลก! นี่คือความหมาย "หน่วยความจำที่สั่งอย่างอ่อน" fooซึ่งอาจเกิดขึ้นได้แม้ว่าคอมไพเลอร์มีทั้งหมดของร้านค้าในคอนสตรัคก่อนร้านที่จะ หากfooเป็นvolatileที่เก็บfooจะมีการปล่อยซีแมนทิกส์และฮาร์ดแวร์รับประกันว่าการเขียนทั้งหมดก่อนที่การเขียนfooจะปรากฏแก่โปรเซสเซอร์อื่นก่อนที่จะอนุญาตให้เขียนfooได้
เป็นไปได้fooอย่างไรที่การจัดลำดับการเขียนซ้ำจะไม่ดี? หากการถือครองบรรทัดแคชfooอยู่ในแคชและร้านค้าในตัวสร้างพลาดแคชดังนั้นจึงเป็นไปได้ที่ร้านค้าจะเสร็จสมบูรณ์เร็วกว่าการเขียนไปยังแคชที่หายไป
สถาปัตยกรรม Itanium (แย่มาก) จาก Intel ได้สั่งหน่วยความจำอย่างอ่อน โปรเซสเซอร์ที่ใช้ใน XBox 360 เดิมได้สั่งหน่วยความจำอย่างอ่อน หน่วยประมวลผล ARM หลายรุ่นรวมถึง ARMv7-A ที่ได้รับความนิยมสูงได้สั่งซื้อหน่วยความจำน้อย
นักพัฒนามักไม่เห็นการแข่งขันของข้อมูลเหล่านี้เพราะสิ่งต่าง ๆ เช่นล็อคจะทำสิ่งกีดขวางหน่วยความจำเต็มโดยพื้นฐานแล้วสิ่งเดียวกับที่ได้รับและเผยแพร่ความหมายในเวลาเดียวกัน ไม่สามารถทำการโหลดภายในตัวล็อคได้อย่างพิเศษก่อนที่จะได้รับตัวล็อคซึ่งจะล่าช้าจนกว่าจะได้รับตัวล็อค ไม่มีร้านค้าใดสามารถล่าช้าในการปลดล็อคคำสั่งที่ปลดล็อคจะล่าช้าจนกว่าการเขียนทั้งหมดที่ทำภายในล็อคจะปรากฏทั่วโลก
ตัวอย่างที่สมบูรณ์มากขึ้นคือรูปแบบ "การตรวจสอบการล็อคสองครั้ง" วัตถุประสงค์ของรูปแบบนี้คือการหลีกเลี่ยงการได้รับการล็อคเพื่อขี้เกียจเริ่มต้นวัตถุ
ติดขัดจาก Wikipedia:
public class MySingleton {
private static object myLock = new object();
private static volatile MySingleton mySingleton = null;
private MySingleton() {
}
public static MySingleton GetInstance() {
if (mySingleton == null) { // 1st check
lock (myLock) {
if (mySingleton == null) { // 2nd (double) check
mySingleton = new MySingleton();
// Write-release semantics are implicitly handled by marking
// mySingleton with 'volatile', which inserts the necessary memory
// barriers between the constructor call and the write to mySingleton.
// The barriers created by the lock are not sufficient because
// the object is made visible before the lock is released.
}
}
}
// The barriers created by the lock are not sufficient because not all threads
// will acquire the lock. A fence for read-acquire semantics is needed between
// the test of mySingleton (above) and the use of its contents. This fence
// is automatically inserted because mySingleton is marked as 'volatile'.
return mySingleton;
}
}
ในตัวอย่างนี้ร้านค้าในที่MySingletonคอนสตรัคอาจจะไม่สามารถมองเห็นการประมวลผลอื่น ๆ mySingletonก่อนที่ร้านที่จะ หากสิ่งนั้นเกิดขึ้นเธรดอื่น ๆ ที่มองดู mySingleton จะไม่ได้รับการล็อคและพวกเขาจะไม่จำเป็นต้องหยิบการเขียนไปที่ตัวสร้าง
volatileไม่เคยป้องกันการแคช สิ่งที่ทำคือรับประกันการสั่งซื้อซึ่งโปรเซสเซอร์อื่น ๆ "เห็น" เขียน การเปิดตัวร้านค้าจะชะลอการจัดเก็บจนกว่าการเขียนที่ค้างอยู่ทั้งหมดจะเสร็จสมบูรณ์และมีการออกรอบรถบัสซึ่งบอกให้โปรเซสเซอร์อื่น ๆ ยกเลิก / เขียนกลับแคชของพวกเขาหากพวกเขามีแคชที่เกี่ยวข้อง การรับโหลดจะล้างการอ่านที่มีการคาดเดาใด ๆ เพื่อให้แน่ใจว่าจะไม่เป็นค่าเก่าจากอดีต