“ อะตอมมิก” หมายถึงอะไรในการเขียนโปรแกรม

ในหนังสือ Java ที่มีประสิทธิภาพจะระบุ:

ข้อกำหนดทางภาษารับประกันว่าการอ่านหรือการเขียนตัวแปรนั้นเป็นอะตอมมิกเว้นแต่ตัวแปรนั้นเป็นประเภทlongหรือdouble[JLS, 17.4.7]

"atomic" หมายถึงอะไรในบริบทของการเขียนโปรแกรม Java หรือการเขียนโปรแกรมโดยทั่วไป?

นี่คือตัวอย่างเนื่องจากตัวอย่างมักชัดเจนกว่าคำอธิบายที่ยาว สมมติว่าเป็นตัวแปรประเภทfoo longการดำเนินการต่อไปนี้ไม่ใช่การดำเนินการแบบปรมาณู:

foo = 65465498L;

แท้จริงแล้วตัวแปรนั้นถูกเขียนโดยใช้สองการดำเนินการแยกกัน: อันที่เขียน 32 บิตแรกและอีกอันหนึ่งซึ่งเขียน 32 บิตสุดท้าย นั่นหมายความว่าเธรดอื่นอาจอ่านค่าของfooและดูสถานะสื่อกลาง

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

วิธีง่ายๆในการทำเช่นนี้คือการทำให้ตัวแปรมีความผันผวน :

private volatile long foo;

หรือซิงโครไนซ์การเข้าถึงตัวแปร:

public synchronized void setFoo(long value) {
    this.foo = value;
}

public synchronized long getFoo() {
    return this.foo;
}
// no other use of foo outside of these two methods, unless also synchronized

หรือเพื่อแทนที่ด้วยAtomicLong:

private AtomicLong foo;

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

มันเป็นสิ่งที่ "ปรากฏต่อส่วนที่เหลือของระบบที่จะเกิดขึ้นทันที" และอยู่ภายใต้การจัดประเภทของLinearizabilityในกระบวนการคำนวณ หากต้องการอ้างอิงบทความที่ลิงก์เพิ่มเติม:

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

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

คำพูดของคุณเน้นว่าสิ่งนี้ไม่จำเป็นต้องเป็นพฤติกรรมที่คาดหวังในทุกกรณี

เพิ่งพบโพสต์การดำเนินการปรมาณูกับปลอดปรมาณูจะเป็นประโยชน์กับฉันมาก

"การดำเนินการกับหน่วยความจำที่ใช้ร่วมกันนั้นเป็นอะตอมถ้าทำในขั้นตอนเดียวที่สัมพันธ์กับเธรดอื่น ๆ

เมื่อมีการดำเนินการเก็บอะตอมมิกในหน่วยความจำที่ใช้ร่วมกันไม่มีเธรดอื่นสามารถสังเกตเห็นการปรับเปลี่ยนครึ่งเสร็จสมบูรณ์

เมื่อมีการดำเนินการโหลดปรมาณูในตัวแปรที่ใช้ร่วมกันมันจะอ่านค่าทั้งหมดตามที่ปรากฏในช่วงเวลาเดียวในเวลา "

หากคุณมีหลายเธรดที่ใช้งานวิธีการ m1 และ m2 ในรหัสด้านล่าง:

class SomeClass {
    private int i = 0;

    public void m1() { i = 5; }
    public int m2() { return i; }
}

คุณมีการรับประกันว่าการเรียกเธรดใด ๆm2จะอ่านเป็น 0 หรือ 5

ในทางกลับกันด้วยรหัสนี้ (ที่iยาว):

class SomeClass {
    private long i = 0;

    public void m1() { i = 1234567890L; }
    public long m2() { return i; }
}

การเรียกเธรดm2สามารถอ่าน 0, 1234567890L หรือค่าสุ่มอื่น ๆ ได้เนื่องจากคำสั่งi = 1234567890Lไม่รับประกันว่าจะเป็น atomic สำหรับlong(JVM สามารถเขียน 32 บิตแรกและ 32 บิตสุดท้ายในสองการดำเนินการและเธรดอาจสังเกตเห็นiในระหว่าง) .

ใน Java การอ่านและการเขียนฟิลด์ทุกประเภทยกเว้น long และ double เกิดขึ้นแบบ atom และถ้าฟิลด์ถูกประกาศด้วยตัวแก้ไขแบบระเหยแม้ long และ double จะอ่านและเขียนแบบ atom นั่นคือเราได้รับ 100% ไม่ว่าจะเกิดจากที่ใดหรือเกิดอะไรขึ้นที่นั่นและจะไม่มีผลลัพธ์ระหว่างกลางในตัวแปร