เหตุใด i ++ จึงไม่ใช่ปรมาณู

เหตุใดi++อะตอมจึงไม่อยู่ใน Java

เพื่อให้ลึกลงไปอีกนิดใน Java ฉันพยายามนับความถี่ในการดำเนินการลูปในเธรด

ดังนั้นฉันจึงใช้ไฟล์

private static int total = 0;

ในคลาสหลัก

ฉันมีสองกระทู้

• หัวข้อ 1: พิมพ์ System.out.println("Hello from Thread 1!");
• หัวข้อ 2: พิมพ์ System.out.println("Hello from Thread 2!");

และฉันนับบรรทัดที่พิมพ์ด้วยเธรด 1 และเธรด 2 แต่บรรทัดของเธรด 1 + บรรทัดของเธรด 2 ไม่ตรงกับจำนวนบรรทัดทั้งหมดที่พิมพ์ออกมา

นี่คือรหัสของฉัน:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Test {

    private static int total = 0;
    private static int countT1 = 0;
    private static int countT2 = 0;
    private boolean run = true;

    public Test() {
        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
        newCachedThreadPool.execute(t1);
        newCachedThreadPool.execute(t2);
        try {
            Thread.sleep(1000);
        }
        catch (InterruptedException ex) {
            Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);
        }
        run = false;
        try {
            Thread.sleep(1000);
        }
        catch (InterruptedException ex) {
            Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);
        }
        System.out.println((countT1 + countT2 + " == " + total));
    }

    private Runnable t1 = new Runnable() {
        @Override
        public void run() {
            while (run) {
                total++;
                countT1++;
                System.out.println("Hello #" + countT1 + " from Thread 2! Total hello: " + total);
            }
        }
    };

    private Runnable t2 = new Runnable() {
        @Override
        public void run() {
            while (run) {
                total++;
                countT2++;
                System.out.println("Hello #" + countT2 + " from Thread 2! Total hello: " + total);
            }
        }
    };

    public static void main(String[] args) {
        new Test();
    }
}

i++อาจจะไม่อะตอมในชวาเพราะ atomicity i++เป็นความต้องการพิเศษที่ไม่ได้อยู่ในส่วนของการใช้งานของ ข้อกำหนดนั้นมีค่าใช้จ่ายที่สำคัญ: มีค่าใช้จ่ายจำนวนมากในการสร้างอะตอมของการดำเนินการที่เพิ่มขึ้น มันเกี่ยวข้องกับการซิงโครไนซ์ทั้งในระดับซอฟต์แวร์และฮาร์ดแวร์ที่ไม่จำเป็นต้องเพิ่มขึ้นตามปกติ

คุณสามารถทำให้ข้อโต้แย้งว่าควรจะได้รับการออกแบบและจัดทำเอกสารเป็นเฉพาะการดำเนินการเพิ่มขึ้นของอะตอมเพื่อให้เพิ่มขึ้นไม่ใช่อะตอมจะดำเนินการใช้i++ i = i + 1อย่างไรก็ตามสิ่งนี้จะทำลาย "ความเข้ากันได้ทางวัฒนธรรม" ระหว่าง Java และ C และ C ++ เช่นกันมันจะใช้สัญกรณ์ที่สะดวกสบายซึ่งโปรแกรมเมอร์ที่คุ้นเคยกับภาษาคล้ายซีใช้เพื่อให้มันมีความหมายพิเศษที่ใช้เฉพาะในสถานการณ์ที่ จำกัด

รหัส C หรือ C ++ พื้นฐานต้องการfor (i = 0; i < LIMIT; i++)แปลเป็น Java เป็นfor (i = 0; i < LIMIT; i = i + 1); i++เพราะมันจะไม่เหมาะสมที่จะใช้อะตอม ที่แย่ไปกว่านั้นคือโปรแกรมเมอร์ที่มาจากภาษา C หรือภาษาอื่น ๆ ที่คล้าย C ถึง Java จะใช้i++ต่อไปส่งผลให้มีการใช้คำสั่งอะตอมโดยไม่จำเป็น

แม้ในระดับชุดคำสั่งของเครื่องการดำเนินการประเภทการเพิ่มขึ้นมักจะไม่เป็นปรมาณูเนื่องจากเหตุผลด้านประสิทธิภาพ ใน x86 ต้องใช้คำสั่งพิเศษ "lock prefix" เพื่อสร้างincคำสั่ง atomic: ด้วยเหตุผลเดียวกับข้างต้น ถ้าincเป็นปรมาณูเสมอมันจะไม่ถูกใช้เมื่อจำเป็นต้องใช้ non-atomic inc โปรแกรมเมอร์และคอมไพเลอร์จะสร้างโค้ดที่โหลดเพิ่ม 1 และจัดเก็บเพราะมันจะเร็วกว่า

ในสถาปัตยกรรมชุดคำสั่งบางชุดไม่มีอะตอมincหรืออาจไม่มีincเลย ในการทำ atomic inc บน MIPS คุณต้องเขียนซอฟต์แวร์วนซ้ำซึ่งใช้lland sc: load-linked และ store-conditional Load-linked อ่านคำและ store-conditional จะจัดเก็บค่าใหม่หากคำนั้นไม่มีการเปลี่ยนแปลงหรือมิฉะนั้นจะล้มเหลว (ซึ่งตรวจพบและทำให้เกิดการลองใหม่)

i++ เกี่ยวข้องกับการดำเนินการสองอย่าง:

1. อ่านค่าปัจจุบันของ i
2. เพิ่มค่าและกำหนดให้ i

เมื่อเธรดสองเธรดทำงานi++กับตัวแปรเดียวกันพร้อมกันทั้งคู่อาจได้รับค่าปัจจุบันเท่ากันiจากนั้นจึงเพิ่มขึ้นและตั้งค่าเป็นi+1ดังนั้นคุณจะได้รับการเพิ่มทีละครั้งแทนที่จะเป็นสอง

ตัวอย่าง:

int i = 5;
Thread 1 : i++;
           // reads value 5
Thread 2 : i++;
           // reads value 5
Thread 1 : // increments i to 6
Thread 2 : // increments i to 6
           // i == 6 instead of 7

สิ่งที่สำคัญคือ JLS (ข้อกำหนดภาษา Java) แทนที่จะเป็นวิธีการใช้งาน JVM ที่หลากหลายอาจมีหรือไม่มีคุณสมบัติบางอย่างของภาษา JLS กำหนดตัวดำเนินการ ++ postfix ในข้อ 15.14.2 ซึ่งระบุว่า ia "ค่า 1 ถูกเพิ่มให้กับค่าของตัวแปรและผลรวมจะถูกเก็บไว้ในตัวแปร" ไม่มีที่ไหนกล่าวถึงหรือบอกใบ้ถึงมัลติเธรดหรือปรมาณู สำหรับเหล่านี้ JLS ให้ระเหยและตรงกัน นอกจากนี้ยังมีแพ็คเกจjava.util.concurrent.atomic (ดูhttp://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/package-summary.html )

เหตุใด i ++ จึงไม่ใช่ atomic ใน Java

มาแบ่งการดำเนินการเพิ่มเป็นหลายคำสั่ง:

หัวข้อที่ 1 และ 2:

1. ดึงมูลค่ารวมจากหน่วยความจำ
2. เพิ่ม 1 ในค่า
3. เขียนกลับไปที่ความทรงจำ

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

i++ เป็นคำสั่งที่เกี่ยวข้องกับการดำเนินการ 3 อย่าง:

1. อ่านค่าปัจจุบัน
2. เขียนค่าใหม่
3. จัดเก็บค่าใหม่

การดำเนินการทั้งสามนี้ไม่ได้หมายถึงการดำเนินการในขั้นตอนเดียวหรือกล่าวอีกนัยหนึ่งi++ไม่ใช่การ ดำเนินการแบบผสม เป็นผลให้ทุกสิ่งผิดพลาดได้เมื่อมีเธรดมากกว่าหนึ่งเธรดที่เกี่ยวข้องในการดำเนินการเดียว แต่ไม่รวมกัน

พิจารณาสถานการณ์ต่อไปนี้:

ครั้งที่ 1 :

Thread A fetches i
Thread B fetches i

เวลา 2 :

Thread A overwrites i with a new value say -foo-
Thread B overwrites i with a new value say -bar-
Thread B stores -bar- in i

// At this time thread B seems to be more 'active'. Not only does it overwrite 
// its local copy of i but also makes it in time to store -bar- back to 
// 'main' memory (i)

ครั้งที่ 3 :

Thread A attempts to store -foo- in memory effectively overwriting the -bar- 
value (in i) which was just stored by thread B in Time 2.

Thread B has nothing to do here. Its work was done by Time 2. However it was 
all for nothing as -bar- was eventually overwritten by another thread.

และคุณก็มี สภาพการแข่งขัน

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

ปล

หนังสือที่ยอดเยี่ยมครอบคลุมประเด็นเหล่านั้นทั้งหมดและบางเล่มก็คือ: Java Concurrency in Practice

ใน JVM การเพิ่มขึ้นเกี่ยวข้องกับการอ่านและการเขียนดังนั้นจึงไม่ใช่ปรมาณู

หากการดำเนินการi++เป็นแบบปรมาณูคุณจะไม่มีโอกาสอ่านค่าจากมัน นี่คือสิ่งที่คุณต้องการทำโดยใช้i++(แทนที่จะใช้++i)

ตัวอย่างเช่นดูรหัสต่อไปนี้:

public static void main(final String[] args) {
    int i = 0;
    System.out.println(i++);
}

ในกรณีนี้เราคาดว่าผลลัพธ์จะเป็น: 0 (เนื่องจากเราโพสต์ส่วนเพิ่มเช่นอ่านก่อนแล้วอัปเดต)

นี่เป็นสาเหตุหนึ่งที่การดำเนินการไม่สามารถเป็นอะตอมได้เนื่องจากคุณต้องอ่านค่า (และทำอะไรบางอย่างกับมัน) จากนั้นอัปเดตค่า

อีกเหตุผลที่สำคัญคือการทำบางสิ่งบางอย่างในอะตอมมักจะใช้เวลามากขึ้นเนื่องจากการล็อค คงเป็นเรื่องงี่เง่าหากการดำเนินการทั้งหมดในยุคดั้งเดิมต้องใช้เวลานานขึ้นเล็กน้อยสำหรับกรณีที่เกิดขึ้นได้ยากเมื่อผู้คนต้องการมีการปฏิบัติการทางปรมาณู นั่นคือเหตุผลที่พวกเขาเพิ่มAtomicIntegerและคลาสอะตอมอื่น ๆในภาษา

มีสองขั้นตอน:

1. ดึงฉันจากหน่วยความจำ
2. ตั้งค่า i + 1 เป็น i

ดังนั้นจึงไม่ใช่การทำงานของอะตอม เมื่อ thread1 รัน i ++ และ thread2 รัน i ++ ค่าสุดท้ายของ i อาจเป็น i + 1

เห็นพ้องด้วย (คนThreadชั้นเรียนและดังกล่าว) เป็นคุณลักษณะที่เพิ่มเข้ามาใน v1.0 ของJava i++ถูกเพิ่มในเบต้าก่อนหน้านั้นและด้วยเหตุนี้จึงยังมีโอกาสมากกว่าในการใช้งานดั้งเดิม (มากหรือน้อย)

ขึ้นอยู่กับโปรแกรมเมอร์ในการซิงโครไนซ์ตัวแปร ตรวจสอบการกวดวิชาของออราเคิลเกี่ยวกับเรื่องนี้

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

ตัวดำเนินการ ++ ถูกกำหนดไว้ใน B (1969) ซึ่งมาก่อนจาวาและเธรดโดยใช้เพียงเล็กน้อย