ระเหยกับลูกโซ่กับล็อค

สมมติว่าคลาสมีpublic int counterฟิลด์ที่เข้าถึงได้โดยหลายเธรด นี่intเป็นเพียงการเพิ่มหรือลดเท่านั้น

หากต้องการเพิ่มฟิลด์นี้ควรใช้วิธีการใดและเพราะเหตุใด

• lock(this.locker) this.counter++;,
• Interlocked.Increment(ref this.counter);,
• เปลี่ยนการปรับปรุงการเข้าถึงการcounterpublic volatile

ตอนนี้ที่ผมได้ค้นพบvolatileฉันได้รับการลบหลายงบและการใช้งานของlock Interlockedแต่มีเหตุผลที่จะไม่ทำเช่นนี้หรือไม่?

แย่ที่สุด (ใช้งานไม่ได้จริง)

เปลี่ยน accessifier ของcounterเป็นpublic volatile

อย่างที่คนอื่น ๆ พูดถึงสิ่งนี้ด้วยตัวของมันเองไม่ได้ปลอดภัยอะไรเลย ประเด็นvolatileก็คือว่ามีหลายเธรดที่ทำงานบน CPU หลายตัวสามารถและจะแคชข้อมูลและคำสั่งซื้อซ้ำ

หากไม่ใช่ volatileและ CPU A เพิ่มค่าหน่วยความจำ CPU B อาจไม่เห็นค่าที่เพิ่มขึ้นจริงจนกระทั่งบางครั้งในภายหลังซึ่งอาจทำให้เกิดปัญหา

หากเป็นvolatileเช่นนี้จะช่วยให้มั่นใจว่าทั้งสองซีพียูสามารถดูข้อมูลเดียวกันได้ในเวลาเดียวกัน มันไม่ได้หยุดพวกเขาจากการสอดแทรกการอ่านและการเขียนซึ่งเป็นปัญหาที่คุณพยายามหลีกเลี่ยง

อันดับสอง:

lock(this.locker) this.counter++;

วิธีนี้ปลอดภัยที่จะทำ (หากคุณจำได้ในlockทุกที่ที่คุณเข้าถึงthis.counter) จะป้องกันไม่ให้กระทู้อื่น ๆ lockerจากการดำเนินการรหัสอื่นใดที่จะรักษาโดย การใช้ตัวล็อคยังช่วยป้องกันปัญหาการเรียงลำดับใหม่ของ CPU แบบหลายจุดซึ่งดีมาก

ปัญหาคือล็อคช้าและถ้าคุณใช้lockerในที่อื่นที่ไม่เกี่ยวข้องจริงๆคุณสามารถปิดกั้นเธรดอื่น ๆ ได้โดยไม่มีเหตุผล

ดีที่สุด

Interlocked.Increment(ref this.counter);

วิธีนี้ปลอดภัยเนื่องจากการอ่านเพิ่มและเขียนใน 'หนึ่งครั้ง' อย่างมีประสิทธิภาพซึ่งไม่สามารถถูกขัดจังหวะได้ ด้วยเหตุนี้จึงไม่ส่งผลกระทบต่อรหัสอื่น ๆ และคุณไม่จำเป็นต้องจำที่จะล็อคที่อื่นเช่นกัน นอกจากนี้ยังเร็วมาก (อย่างที่ MSDN บอกว่าสำหรับซีพียูสมัยใหม่นี่มักจะเป็นคำสั่ง CPU เพียงตัวเดียว)

ฉันไม่แน่ใจทั้งหมด แต่ถ้ามันได้รับรอบ CPU อื่น ๆ เรียงลำดับสิ่งต่าง ๆ หรือถ้าคุณยังต้องรวมความผันผวนกับการเพิ่มขึ้น

InterlockedNotes:

1. วิธีที่ถูกล็อคจะปลอดภัยอย่างต่อเนื่องในจำนวนแกนหรือซีพียูใด ๆ
2. วิธีการเชื่อมต่อใช้รั้วเต็มรอบคำแนะนำพวกเขาดำเนินการดังนั้นการสั่งซื้อใหม่จะไม่เกิดขึ้น
3. ไม่จำเป็นต้องใช้วิธีการที่เชื่อมต่อกันหรือแม้กระทั่งไม่สนับสนุนการเข้าถึงเขตข้อมูลที่มีความผันผวนเนื่องจากความผันผวนจะถูกวางครึ่งรั้วรอบการดำเนินการในสนามที่กำหนด

เชิงอรรถ: ความผันผวนที่ดีจริงๆ

เช่นเดียวกับที่volatileไม่ได้ป้องกันปัญหาการมัลติเธรดเหล่านี้มันมีไว้เพื่ออะไร? ตัวอย่างที่ดีคือการพูดว่าคุณมีสองกระทู้หนึ่งซึ่งมักจะเขียนถึงตัวแปร (พูดqueueLength) และหนึ่งที่มักจะอ่านจากตัวแปรเดียวกันนั้น

หากqueueLengthไม่ระเหยเธรด A อาจเขียนห้าครั้ง แต่เธรด B อาจเห็นการเขียนเหล่านั้นว่าล่าช้า (หรืออาจเกิดขึ้นในลำดับที่ไม่ถูกต้อง)

วิธีแก้ปัญหาคือล็อค แต่คุณสามารถใช้ความผันผวนในสถานการณ์นี้ได้ สิ่งนี้จะช่วยให้มั่นใจได้ว่าเธรด B จะเห็นสิ่งที่ทันสมัยที่สุดเสมอที่เธรด A เขียนไว้ โปรดทราบว่าตรรกะนี้ใช้ได้เฉพาะในกรณีที่คุณมีนักเขียนที่ไม่เคยอ่านและผู้อ่านที่ไม่เคยเขียนและหากสิ่งที่คุณเขียนเป็นค่าอะตอมมิก ทันทีที่คุณอ่าน - แก้ไข - เขียนเดียวคุณจะต้องไปที่การดำเนินการ Interlocked หรือใช้ล็อค

แก้ไข:ตามที่ระบุไว้ในความคิดเห็นวันนี้ฉันยินดีที่จะใช้Interlockedสำหรับกรณีของตัวแปรเดียวที่เห็นได้ชัดว่าโอเค เมื่อมันซับซ้อนมากขึ้นฉันจะยังคงล็อค ...

การใช้volatileจะไม่ช่วยเมื่อคุณต้องการเพิ่ม - เนื่องจากการอ่านและการเขียนเป็นคำแนะนำแยกต่างหาก เธรดอื่นสามารถเปลี่ยนค่าหลังจากที่คุณอ่าน แต่ก่อนที่จะเขียนกลับ

โดยส่วนตัวฉันมักจะล็อค - มันง่ายกว่าที่จะได้รับในทางที่ถูกต้องชัดเจนกว่าความผันผวนอย่างใดอย่างหนึ่งหรือ Interlocked การเพิ่มขึ้น เท่าที่ฉันเป็นห่วงมัลติเธรดแบบล็อกฟรีสำหรับผู้เชี่ยวชาญการทำเกลียวจริงซึ่งฉันไม่ใช่คนเดียว ถ้าโจดัฟฟี่และทีมของเขาสร้างห้องสมุดที่สวยงามซึ่งจะทำการเปรียบเทียบสิ่งต่าง ๆ โดยไม่ล็อคเท่าสิ่งที่ฉันสร้างมันยอดเยี่ยมมากและฉันจะใช้มันในการเต้นของหัวใจ - แต่เมื่อฉันทำเกลียวตัวเองฉันพยายาม ง่าย ๆ เข้าไว้.

" volatile" ไม่ได้แทนที่Interlocked.Increment! มันทำให้แน่ใจว่าตัวแปรไม่ได้ถูกแคช แต่ใช้โดยตรง

การเพิ่มตัวแปรต้องใช้การปฏิบัติการจริงสามอย่าง:

1. อ่าน
2. การเพิ่มขึ้น
3. เขียน

Interlocked.Increment ดำเนินการทั้งสามส่วนเป็นการดำเนินการปรมาณูเดียว

การล็อคหรือการเพิ่มอินเตอร์ล็อคคือสิ่งที่คุณกำลังมองหา

ความผันผวนไม่ได้เป็นอย่างที่คุณต้องการ - เพียงแค่บอกคอมไพเลอร์ให้จัดการกับตัวแปรที่เปลี่ยนแปลงตลอดเวลาแม้ว่าเส้นทางรหัสปัจจุบันจะอนุญาตให้คอมไพเลอร์ปรับการอ่านจากหน่วยความจำให้เหมาะสม

เช่น

while (m_Var)
{ }

หาก m_Var ถูกตั้งค่าเป็น false ในเธรดอื่น แต่ไม่ได้ประกาศว่า volatile คอมไพเลอร์มีอิสระที่จะทำให้วนรอบไม่สิ้นสุด (แต่ไม่ได้หมายความว่ามันจะเสมอ) โดยการตรวจสอบกับ CPU register (เช่น EAX เพราะนั่นคือ สิ่งที่ m_Var ถูกดึงเข้ามาตั้งแต่ต้น) แทนที่จะปล่อยให้อ่านอีกครั้งไปยังตำแหน่งหน่วยความจำของ m_Var (ซึ่งอาจถูกแคช - เราไม่รู้และไม่สนใจและนั่นคือจุดเชื่อมโยงแคชของ x86 / x64) โพสต์ทั้งหมดก่อนหน้านี้โดยคนอื่น ๆ ที่กล่าวถึงการจัดเรียงคำสั่งใหม่เพียงแค่แสดงว่าพวกเขาไม่เข้าใจสถาปัตยกรรม x86 / x64 สารระเหยไม่ได้ปัญหาการอ่าน / เขียนอุปสรรคตามที่ระบุไว้โดยโพสต์ก่อนหน้าว่า 'มันป้องกันการเรียงลำดับใหม่' ในความเป็นจริงแล้วขอบคุณอีกครั้งสำหรับโปรโตคอล MESI เราจึงมั่นใจได้ว่าผลลัพธ์ที่เราอ่านจะเหมือนกันตลอดทั้งซีพียูโดยไม่คำนึงว่าผลลัพธ์ที่แท้จริงได้ถูกยกเลิกไปยังหน่วยความจำทางกายภาพหรือเพียงแค่อยู่ในแคชของ CPU ท้องถิ่น ฉันจะไม่เข้าไปดูรายละเอียดมากไปกว่านี้ แต่มั่นใจได้เลยว่าถ้ามันผิดพลาด Intel / AMD น่าจะออกตัวประมวลผล! นอกจากนี้ยังหมายความว่าเราไม่ต้องสนใจเรื่องการดำเนินการตามคำสั่ง ฯลฯ ผลลัพธ์จะรับประกันว่าจะออกตามลำดับเสมอ - ไม่เช่นนั้นเราจะถูกยัดไว้!

ด้วย Interlocked Increment โปรเซสเซอร์จะต้องออกไปดึงค่าจากที่อยู่ที่ได้รับจากนั้นเพิ่มขึ้นและเขียนกลับมาทั้งหมดนั้นในขณะที่มีความเป็นเจ้าของเอกสิทธิ์ของสายแคชทั้งหมด (ล็อค xadd) เพื่อให้แน่ใจว่าไม่มีโปรเซสเซอร์อื่นใดที่สามารถแก้ไขได้ คุณค่าของมัน

ด้วยความผันผวนคุณจะยังคงจบลงด้วยการเรียนการสอนเพียง 1 ครั้ง (สมมติว่า JIT นั้นมีประสิทธิภาพอย่างที่ควรจะเป็น) - inc dword ptr [m_Var] อย่างไรก็ตามตัวประมวลผล (cpuA) ไม่ขอความเป็นเจ้าของเฉพาะของบรรทัดแคชในขณะที่ทำทุกอย่างที่ทำกับเวอร์ชันที่เชื่อมต่อกัน ดังที่คุณสามารถจินตนาการได้นั่นหมายความว่าโปรเซสเซอร์อื่น ๆ สามารถเขียนค่าที่ปรับปรุงแล้วกลับไปที่ m_Var หลังจาก cpuA อ่านแล้ว ดังนั้นแทนที่จะเพิ่มค่าสองครั้งคุณจะได้เพียงครั้งเดียว

หวังว่าจะช่วยแก้ปัญหานี้ได้

สำหรับข้อมูลเพิ่มเติมดู 'ทำความเข้าใจกับผลกระทบของเทคนิคล็อคต่ำในแอพแบบมัลติเธรด' - http://msdn.microsoft.com/en-au/magazine/cc163715.aspx

ป.ล. สิ่งที่ทำให้การตอบนี้ช้ามาก คำตอบทั้งหมดนั้นไม่ถูกต้องอย่างโจ่งแจ้ง (โดยเฉพาะคำที่ทำเครื่องหมายว่าเป็นคำตอบ) ในคำอธิบายของพวกเขาฉันแค่ต้องเคลียร์มันให้กับคนอื่นที่อ่านข้อความนี้ shrugs

pps ฉันสมมติว่าเป้าหมายคือ x86 / x64 และไม่ใช่ IA64 (มีรูปแบบหน่วยความจำที่แตกต่างกัน) โปรดทราบว่ารายละเอียด ECMA ของ Microsoft นั้นถูกทำให้แน่นด้วยการระบุรุ่นหน่วยความจำที่อ่อนแอที่สุดแทนที่จะเป็นรุ่นที่แข็งแกร่งที่สุด (จะดีกว่าเสมอเมื่อเทียบกับรุ่นหน่วยความจำที่แข็งแกร่งที่สุดดังนั้นจึงสอดคล้องกันในทุกแพลตฟอร์ม - รหัสอื่น ๆ x64 อาจไม่ทำงานเลยใน IA64 แม้ว่า Intel ได้ใช้โมเดลหน่วยความจำที่แข็งแกร่งเช่นเดียวกันสำหรับ IA64) - Microsoft ยอมรับด้วยตัวเอง - http://blogs.msdn.com/b/cbrumme/archive/2003/05/17/51445.aspx .

ฟังก์ชั่นล็อคไม่ล็อค พวกมันคืออะตอมซึ่งหมายความว่าพวกมันสามารถทำให้เสร็จได้โดยไม่ต้องสลับบริบทระหว่างการเพิ่มขึ้น ดังนั้นจึงไม่มีโอกาสหยุดชะงักหรือรอ

ฉันจะบอกว่าคุณควรจะชอบมันเพื่อล็อคและเพิ่มขึ้น

สารระเหยมีประโยชน์ถ้าคุณต้องการเขียนในเธรดหนึ่งเพื่อให้อ่านในอีกเธรดและถ้าคุณต้องการให้เครื่องมือเพิ่มประสิทธิภาพไม่เรียงลำดับการดำเนินการกับตัวแปรอีกครั้ง (เนื่องจากสิ่งต่าง ๆ เกิดขึ้นในเธรดอื่นที่เครื่องมือเพิ่มประสิทธิภาพไม่รู้จัก) มันเป็นตัวเลือกมุมฉากกับการเพิ่มขึ้นของคุณ

นี่เป็นบทความที่ดีมากหากคุณต้องการอ่านเพิ่มเติมเกี่ยวกับรหัสล็อคฟรีและวิธีที่ถูกต้องในการเขียนมัน

http://www.ddj.com/hpc-high-performance-computing/210604448

การล็อก (... ) ใช้งานได้ แต่อาจบล็อกเธรดและอาจทำให้เกิดการหยุดชะงักหากรหัสอื่นกำลังใช้การล็อกเดียวกันในวิธีที่เข้ากันไม่ได้

Interlocked. * เป็นวิธีที่ถูกต้องในการทำ ... ค่าโสหุ้ยน้อยลงเนื่องจาก CPU ที่ทันสมัยรองรับสิ่งนี้เป็นแบบดั้งเดิม

การระเหยด้วยตัวมันเองนั้นไม่ถูกต้อง เธรดที่พยายามดึงข้อมูลและเขียนกลับมาแก้ไขค่าอาจขัดแย้งกับเธรดอื่นที่ทำเช่นเดียวกัน

ผมได้ทดสอบบางอย่างเพื่อดูว่าทฤษฎีที่ใช้งานได้จริง: kennethxu.blogspot.com/2009/05/interlocked-vs-monitor-performance.html การทดสอบของฉันมุ่งเน้นที่ CompareExchnage มากขึ้น แต่ผลลัพธ์สำหรับการเพิ่มจะคล้ายกัน Interlocked ไม่จำเป็นต้องเร็วขึ้นในสภาพแวดล้อมแบบ multi-cpu นี่คือผลการทดสอบสำหรับการเพิ่มขึ้นในเซิร์ฟเวอร์ซีพียูอายุ 16 ปี 2 ปี อย่าลืมว่าการทดสอบนั้นเกี่ยวข้องกับการอ่านอย่างปลอดภัยหลังจากเพิ่มมากขึ้นซึ่งเป็นเรื่องปกติในโลกแห่งความเป็นจริง

D:\>InterlockVsMonitor.exe 16
Using 16 threads:
          InterlockAtomic.RunIncrement         (ns):   8355 Average,   8302 Minimal,   8409 Maxmial
    MonitorVolatileAtomic.RunIncrement         (ns):   7077 Average,   6843 Minimal,   7243 Maxmial

D:\>InterlockVsMonitor.exe 4
Using 4 threads:
          InterlockAtomic.RunIncrement         (ns):   4319 Average,   4319 Minimal,   4321 Maxmial
    MonitorVolatileAtomic.RunIncrement         (ns):    933 Average,    802 Minimal,   1018 Maxmial

ฉันตอบ Jon Jonas สองและต้องการเพิ่มลิงค์ต่อไปนี้สำหรับทุกคนที่ต้องการทราบเพิ่มเติมเกี่ยวกับ "volatile" และ Interlocked:

ปรมาณูความผันผวนและการเปลี่ยนแปลงไม่ได้ส่วนที่หนึ่ง - (Eric Lippert's Fabulous Adventures In Coding)

อะตอมมิกความผันผวนและการเปลี่ยนแปลงไม่ได้ส่วนที่สอง

อะตอมมิกความผันผวนและการเปลี่ยนแปลงไม่ได้ส่วนที่สาม

Sayonara Volatile - (ภาพรวมของ Wayback Machine ของ Joe Duffy Weblog ตามที่ปรากฎในปี 2012)

ฉันต้องการที่จะเพิ่มการกล่าวถึงในคำตอบอื่น ๆ ความแตกต่างระหว่างvolatile, Interlockedและlock:

คำสำคัญระเหยสามารถนำไปใช้กับสาขาประเภทเหล่านี้ :

• ประเภทอ้างอิง
• ประเภทตัวชี้ (ในบริบทที่ไม่ปลอดภัย) โปรดทราบว่าแม้ว่าตัวชี้สามารถผันผวนได้ แต่วัตถุที่ชี้ไปไม่สามารถทำได้ กล่าวอีกนัยหนึ่งคุณไม่สามารถประกาศ "ตัวชี้" เป็น "เปลี่ยนแปลงได้"
• ประเภทง่ายๆเช่นsbyte, byte, short, ushort, int, uint, char, และfloatbool
• ประเภท enum กับประเภทใดประเภทหนึ่งฐานต่อไปนี้: byte, sbyte, short, ushort, หรือintuint
• พารามิเตอร์ประเภททั่วไปที่รู้จักกันว่าเป็นประเภทอ้างอิง
• IntPtrUIntPtrและ

ประเภทอื่นรวมถึงdoubleและlongไม่สามารถทำเครื่องหมาย "ระเหย" เนื่องจากการอ่านและเขียนไปยังเขตข้อมูลของประเภทเหล่านั้นไม่สามารถรับประกันได้ว่าเป็นอะตอม ในการป้องกันการเข้าถึงแบบหลายเธรดในประเภทของเขตข้อมูลเหล่านั้นให้ใช้Interlockedสมาชิกคลาสหรือป้องกันการเข้าถึงโดยใช้ lockคำสั่ง