นี่คือตัวอย่างที่ดีที่สุดด้วยตัวอย่าง
สมมติว่าเรามีงานง่าย ๆ ที่เราต้องการดำเนินการหลาย ๆ ครั้งในแบบคู่ขนานและเราต้องการที่จะติดตามทั่วโลกในจำนวนครั้งที่มีการดำเนินงานเช่นการนับจำนวนการเข้าชมบนหน้าเว็บ
เมื่อแต่ละเธรดมาถึงจุดที่มันเพิ่มจำนวนการประมวลผลจะมีลักษณะดังนี้:
- อ่านจำนวนครั้งจากหน่วยความจำในการลงทะเบียนโปรเซสเซอร์
- เพิ่มจำนวนนั้น
- เขียนตัวเลขนั้นกลับไปที่หน่วยความจำ
โปรดจำไว้ว่าทุกเธรดสามารถระงับได้ทุกเวลาในกระบวนการนี้ ดังนั้นหากเธรด A ดำเนินการตามขั้นตอนที่ 1 และจากนั้นถูกระงับตามด้วยเธรด B ที่ดำเนินการทั้งสามขั้นตอนเมื่อดำเนินการต่อเธรด A การลงทะเบียนจะมีจำนวนครั้งที่ไม่ถูกต้อง: การลงทะเบียนของมันจะถูกคืนค่าอย่างมีความสุข จาก Hit และเก็บหมายเลขที่เพิ่มขึ้นนั้น
นอกจากนี้จำนวนเธรดอื่นใด ๆ ที่สามารถรันได้ในช่วงเวลาที่เธรด A ถูกหยุดชั่วคราวดังนั้นการนับเธรด A ที่เขียนในตอนท้ายอาจต่ำกว่าการนับที่ถูกต้อง
ด้วยเหตุผลดังกล่าวจึงจำเป็นต้องตรวจสอบให้แน่ใจว่าหากเธรดดำเนินการขั้นตอนที่ 1 จะต้องดำเนินการตามขั้นตอนที่ 3 ก่อนที่จะอนุญาตให้เธรดอื่นดำเนินการขั้นตอนที่ 1 ซึ่งสามารถทำได้โดยเธรดทั้งหมดที่รอการล็อกเดี่ยว และการปลดล็อกเฉพาะหลังจากกระบวนการเสร็จสิ้นเพื่อให้โค้ด "ส่วนที่สำคัญ" นี้ไม่สามารถถูกอินเตอร์ลีลอย่างไม่ถูกต้องทำให้เกิดการนับที่ไม่ถูกต้อง
แต่ถ้าปฏิบัติการเป็นอะตอม
ใช่ในดินแดนแห่งยูนิคอร์นที่มีมนต์ขลังและสายรุ้งที่ซึ่งการเพิ่มขึ้นของอะตอมนั้นจะไม่จำเป็นต้องล็อคตัวอย่างด้านบน
อย่างไรก็ตามสิ่งสำคัญคือต้องตระหนักว่าเราใช้เวลาน้อยมากในโลกของยูนิคอร์นและสายรุ้งที่มีมนต์ขลัง ในเกือบทุกภาษาการเขียนโปรแกรมการดำเนินการเพิ่มขึ้นจะแบ่งออกเป็นสามขั้นตอนข้างต้น นั่นเป็นเพราะแม้ว่าโปรเซสเซอร์สนับสนุนการเพิ่มขึ้นของอะตอมการดำเนินการนั้นมีราคาแพงกว่าอย่างมาก: มันต้องอ่านจากหน่วยความจำปรับเปลี่ยนหมายเลขแล้วเขียนมันกลับไปที่หน่วยความจำ ... และโดยปกติแล้วการเพิ่มขึ้นของอะตอมคือการดำเนินการ สามารถล้มเหลวได้ซึ่งหมายถึงลำดับที่ง่าย ๆ ข้างต้นจะต้องถูกแทนที่ด้วยการวนซ้ำ (ดังที่เราจะเห็นด้านล่าง)
ตั้งแต่แม้ในรหัสแบบมัลติเธรดตัวแปรหลายตัวถูกเก็บไว้ในโลคัลเธรดเดียวโปรแกรมจะมีประสิทธิภาพมากขึ้นหากพวกเขาคิดว่าแต่ละตัวแปรเป็นแบบโลคัลสำหรับเธรดเดี่ยวและให้โปรแกรมเมอร์ดูแลการปกป้องสถานะที่แบ่งใช้ระหว่างเธรด โดยเฉพาะอย่างยิ่งเนื่องจากการปฏิบัติการปรมาณูไม่เพียงพอที่จะแก้ปัญหาการทำเกลียวเช่นที่เราจะเห็นในภายหลัง
ตัวแปรระเหย
หากเราต้องการหลีกเลี่ยงการล็อคสำหรับปัญหานี้ก่อนอื่นเราต้องตระหนักว่าขั้นตอนที่อธิบายไว้ในตัวอย่างแรกของเรานั้นไม่ใช่สิ่งที่เกิดขึ้นในคอมไพล์โค้ดที่ทันสมัย เนื่องจากคอมไพเลอร์คิดว่ามีเพียงเธรดเดียวเท่านั้นที่กำลังแก้ไขตัวแปรแต่ละเธรดจะเก็บสำเนาของแคชไว้ในตัวตัวแปรจนกว่าจะต้องลงทะเบียนตัวประมวลผลสำหรับสิ่งอื่น ตราบใดที่มันมีสำเนาแคชก็ถือว่าไม่จำเป็นต้องกลับไปที่หน่วยความจำและอ่านอีกครั้ง (ซึ่งจะมีราคาแพง) พวกเขาจะไม่เขียนตัวแปรกลับไปยังหน่วยความจำตราบใดที่มันถูกเก็บไว้ในทะเบียน
เราสามารถกลับไปสู่สถานการณ์ที่เราให้ไว้ในตัวอย่างแรก (ด้วยปัญหาการเธรดเดียวกับที่เราระบุข้างต้น) โดยการทำเครื่องหมายตัวแปรเป็นสารระเหยซึ่งบอกคอมไพเลอร์ว่าตัวแปรนี้ถูกแก้ไขโดยผู้อื่นและต้องอ่านจาก หรือเขียนไปยังหน่วยความจำทุกครั้งที่มีการเข้าถึงหรือแก้ไข
ดังนั้นตัวแปรที่ระบุว่าเป็นสารระเหยจะไม่นำเราไปสู่ดินแดนแห่งการเพิ่มขึ้นของอะตอมเพียง แต่ทำให้เราเข้าใกล้เท่าที่เราคิด
ทำให้อะตอมเพิ่มขึ้น
เมื่อเราใช้ตัวแปรที่เปลี่ยนแปลงได้เราสามารถสร้างการทำงานแบบเพิ่มหน่วยของเราโดยใช้ชุดปฏิบัติการแบบมีเงื่อนไขระดับต่ำซึ่งซีพียูสมัยใหม่ส่วนใหญ่รองรับ (มักเรียกว่าการเปรียบเทียบและการตั้งค่าหรือการเปรียบเทียบและสลับ ) วิธีนี้ถูกนำมาใช้เช่นในคลาสAtomicIntegerของ Java :
197 /**
198 * Atomically increments by one the current value.
199 *
200 * @return the updated value
201 */
202 public final int incrementAndGet() {
203 for (;;) {
204 int current = get();
205 int next = current + 1;
206 if (compareAndSet(current, next))
207 return next;
208 }
209 }
วนซ้ำด้านบนทำตามขั้นตอนต่อไปนี้ซ้ำ ๆ จนกระทั่งขั้นตอนที่ 3 สำเร็จ:
- อ่านค่าของตัวแปรที่เปลี่ยนแปลงได้โดยตรงจากหน่วยความจำ
- เพิ่มมูลค่านั้น
- เปลี่ยนค่า (ในหน่วยความจำหลัก) ถ้าหากค่าปัจจุบันในหน่วยความจำหลักนั้นเหมือนกันกับค่าที่เราอ่านในตอนแรกโดยใช้การปฏิบัติการแบบพิเศษของอะตอม
หากขั้นตอนที่ 3 ล้มเหลว (เนื่องจากค่าถูกเปลี่ยนโดยเธรดอื่นหลังจากขั้นตอนที่ 1) มันจะอ่านตัวแปรอีกครั้งโดยตรงจากหน่วยความจำหลักและลองอีกครั้ง
แม้ว่าการดำเนินการเปรียบเทียบและสลับจะมีราคาแพงกว่าการใช้การล็อกเล็กน้อยในกรณีนี้เพราะถ้าเธรดถูกหยุดชั่วคราวหลังจากขั้นตอนที่ 1 เธรดอื่นที่มาถึงขั้นตอนที่ 1 ไม่จำเป็นต้องบล็อกและรอเธรดแรกซึ่ง สามารถป้องกันการสลับบริบทค่าใช้จ่าย เมื่อเธรดแรกดำเนินการต่อมันจะล้มเหลวในความพยายามครั้งแรกในการเขียนตัวแปร แต่จะสามารถดำเนินการต่อโดยการอ่านตัวแปรอีกครั้งซึ่งมีโอกาสน้อยกว่าการเปลี่ยนบริบทที่จะต้องใช้ในการล็อกอีกครั้ง
ดังนั้นเราสามารถไปถึงดินแดนของการเพิ่มขึ้นของอะตอม (หรือการดำเนินการอื่น ๆ ในตัวแปรเดียว) โดยไม่ต้องใช้การล็อคจริงผ่านการเปรียบเทียบและสลับ
ดังนั้นเมื่อจำเป็นต้องล็อคอย่างเคร่งครัด?
หากคุณต้องการแก้ไขตัวแปรมากกว่าหนึ่งตัวในการทำงานแบบปรมาณูการล็อกจะจำเป็นคุณจะไม่พบคำสั่งตัวประมวลผลพิเศษสำหรับสิ่งนั้น
ตราบใดที่คุณทำงานกับตัวแปรตัวเดียวและคุณก็พร้อมสำหรับงานที่คุณทำเพื่อล้มเหลวและต้องอ่านตัวแปรและเริ่มต้นใหม่อีกครั้งการเปรียบเทียบและการสลับจะดีพอ
ลองพิจารณาตัวอย่างที่แต่ละเธรดเพิ่ม 2 เข้ากับตัวแปร X ก่อนแล้วจึงคูณ X ด้วยสอง
ถ้า X เป็นหนึ่งในตอนแรกและมีสองเธรดที่ทำงานอยู่เราคาดว่าผลลัพธ์จะเป็น (((1 + 2) * 2) + 2) * 2 = 16
อย่างไรก็ตามถ้าเธรดสอดแทรกเราสามารถทำได้แม้จะมีการดำเนินการทั้งหมดเป็นอะตอม แต่ก็มีการเพิ่มทั้งคู่เกิดขึ้นก่อนและการคูณจะเกิดขึ้นตามมาทำให้เกิด (1 + 2 + 2) * 2 * 2 = 20
สิ่งนี้เกิดขึ้นเนื่องจากการคูณและการเพิ่มไม่ใช่การดำเนินการสลับ
ดังนั้นการดำเนินการของตัวเองที่เป็นปรมาณูไม่เพียงพอเราต้องทำให้การรวมกันของการดำเนินงานปรมาณู
เราสามารถทำได้โดยใช้การล็อกเพื่อทำให้กระบวนการเป็นอนุกรมหรือเราสามารถใช้ตัวแปรโลคัลหนึ่งตัวเพื่อเก็บค่าของ X เมื่อเราเริ่มการคำนวณของเราตัวแปรโลคัลที่สองสำหรับขั้นตอนกลางจากนั้นใช้การเปรียบเทียบและสลับเพื่อ กำหนดค่าใหม่เฉพาะในกรณีที่ค่าปัจจุบันของ X เท่ากับค่าเดิมของ X หากเราล้มเหลวเราจะต้องเริ่มต้นใหม่อีกครั้งโดยการอ่าน X และทำการคำนวณอีกครั้ง
มีการแลกเปลี่ยนหลายอย่างที่เกี่ยวข้อง: เมื่อการคำนวณนานขึ้นมีแนวโน้มมากขึ้นที่เธรดที่กำลังรันจะถูกระงับและค่าจะถูกแก้ไขโดยเธรดอื่นก่อนที่เราจะดำเนินการต่อความหมายของความล้มเหลวมีแนวโน้มมากขึ้น เวลาประมวลผล ในกรณีที่รุนแรงของเธรดจำนวนมากที่มีการคำนวณที่ใช้เวลานานมากเราอาจมี 100 เธรดอ่านตัวแปรและมีส่วนร่วมในการคำนวณในกรณีนี้เฉพาะการจบครั้งแรกเท่านั้นที่จะประสบความสำเร็จในการเขียนค่าใหม่ ทำการคำนวณให้เสร็จ แต่พบว่าพวกเขาไม่สามารถอัปเดตค่า ... ณ จุดที่พวกเขาแต่ละคนจะอ่านค่าและเริ่มการคำนวณ เราน่าจะมี 99 กระทู้ที่เหลือทำซ้ำปัญหาเดียวกันทำให้เสียเวลาในการประมวลผลจำนวนมหาศาล
การทำให้เป็นอนุกรมอย่างสมบูรณ์ของส่วนที่สำคัญผ่านการล็อคจะดีกว่ามากในสถานการณ์นั้น: 99 เธรดจะระงับเมื่อพวกเขาไม่ได้รับการล็อคและเราจะเรียกใช้แต่ละเธรดเพื่อให้มาถึงที่จุดล็อค
หากการทำให้เป็นอนุกรมไม่สำคัญ (เช่นในกรณีที่เพิ่มขึ้นของเรา) และการคำนวณที่จะหายไปหากการอัพเดทหมายเลขล้มเหลวมีน้อยที่สุดอาจมีข้อได้เปรียบที่สำคัญที่จะได้รับจากการใช้การเปรียบเทียบและสลับเนื่องจากการดำเนินการนั้น แพงน้อยกว่าการล็อค