Mengapa i ++ tidak atom?

Mengapa i++tidak atom di Jawa?

Untuk lebih memahami Java, saya mencoba menghitung seberapa sering loop di thread dijalankan.

Jadi saya menggunakan file

private static int total = 0;

di kelas utama.

Saya memiliki dua utas.

• Thread 1: Cetakan System.out.println("Hello from Thread 1!");
• Benang 2: Cetakan System.out.println("Hello from Thread 2!");

Dan saya menghitung garis yang dicetak oleh utas 1 dan utas 2. Tetapi garis utas 1 + garis utas 2 tidak cocok dengan jumlah total garis yang dicetak.

Ini kode saya:

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++mungkin tidak bersifat atomik di Jawa karena atomisitas merupakan persyaratan khusus yang tidak terdapat dalam sebagian besar penggunaan i++. Persyaratan tersebut memiliki overhead yang signifikan: ada biaya yang besar dalam membuat operasi selisih atom; ini melibatkan sinkronisasi pada tingkat perangkat lunak dan perangkat keras yang tidak perlu dilakukan secara bertahap.

Anda bisa membuat argumen yang i++seharusnya dirancang dan didokumentasikan secara spesifik melakukan kenaikan atom, sehingga kenaikan non-atomik dilakukan dengan menggunakan i = i + 1. Namun, ini akan merusak "kompatibilitas budaya" antara Java, dan C dan C ++. Selain itu, ini akan menghilangkan notasi yang nyaman yang dianggap biasa oleh programmer yang akrab dengan bahasa C-like, memberinya makna khusus yang hanya berlaku dalam keadaan terbatas.

Kode dasar C atau C ++ for (i = 0; i < LIMIT; i++)akan diterjemahkan ke dalam Java sebagai for (i = 0; i < LIMIT; i = i + 1); karena tidak pantas menggunakan atom i++. Yang lebih buruk, pemrogram yang berasal dari C atau bahasa mirip C lainnya ke Java akan i++tetap menggunakannya , mengakibatkan penggunaan instruksi atomik yang tidak perlu.

Bahkan pada level set instruksi mesin, operasi tipe increment biasanya tidak atomic karena alasan kinerja. Dalam x86, instruksi khusus "kunci awalan" harus digunakan untuk membuat incinstruksi atom: untuk alasan yang sama seperti di atas. Jika incselalu atom, itu tidak akan pernah digunakan ketika inc non-atom diperlukan; programmer dan compiler akan menghasilkan kode yang memuat, menambahkan 1 dan menyimpan, karena itu akan jauh lebih cepat.

Dalam beberapa arsitektur set instruksi, tidak ada atom incatau mungkin tidak ada incsama sekali; untuk melakukan atomic inc di MIPS, Anda harus menulis loop perangkat lunak yang menggunakan lland sc: load-linked, dan store-conditional. Load-linked membaca kata tersebut, dan store-conditional menyimpan nilai baru jika kata tersebut tidak berubah, atau gagal (yang terdeteksi dan menyebabkan percobaan ulang).

i++ melibatkan dua operasi:

1. membaca nilai saat ini dari i
2. menambah nilai dan menetapkannya ke i

Saat dua utas bekerja i++pada variabel yang sama pada saat yang sama, keduanya mungkin mendapatkan nilai saat ini yang sama i, lalu menaikkan dan menyetelnya ke i+1, jadi Anda akan mendapatkan satu inkrementasi, bukan dua.

Contoh:

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

Yang penting adalah JLS (Spesifikasi Bahasa Java) daripada bagaimana berbagai implementasi JVM mungkin atau mungkin tidak mengimplementasikan fitur bahasa tertentu. JLS mendefinisikan operator ++ postfix dalam klausul 15.14.2 yang mengatakan ia "nilai 1 ditambahkan ke nilai variabel dan jumlahnya disimpan kembali ke dalam variabel". Tidak ada yang menyebutkan atau mengisyaratkan multithreading atau atomicity. Untuk ini, JLS menyediakan volatile dan sinkronisasi . Selain itu, ada paket java.util.concurrent.atomic (lihat http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/package-summary.html )

Mengapa i ++ tidak atom di Java?

Mari kita pecahkan operasi increment menjadi beberapa pernyataan:

Benang 1 & 2:

1. Ambil nilai total dari memori
2. Tambahkan 1 ke nilai
3. Tulis kembali ke memori

Jika tidak ada sinkronisasi, katakanlah Thread satu telah membaca nilai 3 dan menaikkannya menjadi 4, tetapi belum menuliskannya kembali. Pada titik ini, pengalih konteks terjadi. Utas dua membaca nilai 3, menambahnya dan sakelar konteks terjadi. Meskipun kedua utas telah menambah nilai total, itu masih akan menjadi 4 - kondisi balapan.

i++ adalah pernyataan yang hanya melibatkan 3 operasi:

1. Baca nilai saat ini
2. Tulis nilai baru
3. Simpan nilai baru

Ketiga operasi ini tidak dimaksudkan untuk dijalankan dalam satu langkah atau dengan kata lain i++bukan operasi gabungan . Akibatnya, segala macam hal bisa salah jika lebih dari satu utas terlibat dalam operasi tunggal tetapi non-gabungan.

Pertimbangkan skenario berikut ini:

Waktu 1 :

Thread A fetches i
Thread B fetches i

Waktu 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)

Waktu 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.

Dan begitulah. Kondisi balapan.

Itu sebabnya i++tidak atom. Jika ya, semua ini tidak akan terjadi dan masing-masing fetch-update-storeakan terjadi secara atomik. Itulah tepatnya AtomicIntegeruntuk dan dalam kasus Anda itu mungkin cocok.

PS

Sebuah buku yang sangat bagus yang mencakup semua masalah itu dan beberapa di antaranya adalah ini: Java Concurrency in Practice

Dalam JVM, kenaikan melibatkan membaca dan menulis, jadi ini bukan atom.

Jika operasi ini i++akan menjadi atom Anda tidak akan memiliki kesempatan untuk membaca nilai darinya. Inilah yang ingin Anda lakukan dengan menggunakan i++(daripada menggunakan ++i).

Misalnya lihat kode berikut:

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

Dalam hal ini kami mengharapkan outputnya menjadi: 0 (karena kami memposting kenaikan, misalnya membaca pertama, kemudian memperbarui)

Ini adalah salah satu alasan mengapa operasi tidak bisa atomic, karena Anda perlu membaca nilai (dan melakukan sesuatu dengannya) dan kemudian memperbarui nilainya.

Alasan penting lainnya adalah melakukan sesuatu secara atomik biasanya membutuhkan lebih banyak waktu karena penguncian. Akan konyol jika semua operasi pada primitif membutuhkan waktu sedikit lebih lama untuk kasus yang jarang terjadi ketika orang ingin melakukan operasi atom. Itulah mengapa mereka telah menambahkan AtomicIntegerdan kelas atom lainnya ke bahasa tersebut.

Ada dua langkah:

1. ambil saya dari memori
2. setel i + 1 ke i

jadi ini bukan operasi atom. Ketika thread1 menjalankan i ++, dan thread2 menjalankan i ++, nilai akhir dari i mungkin adalah i + 1.

Concurrency ( Threadkelas dan semacamnya) adalah fitur tambahan di v1.0 Java . i++telah ditambahkan dalam versi beta sebelumnya, dan karena itu, kemungkinan besar masih dalam penerapan aslinya (kurang lebih).

Terserah programmer untuk menyinkronkan variabel. Lihat tutorial Oracle tentang ini .

Sunting: Untuk memperjelas, i ++ adalah prosedur yang terdefinisi dengan baik yang mendahului Java, dan karena itu perancang Java memutuskan untuk mempertahankan fungsionalitas asli dari prosedur itu.

Operator ++ didefinisikan dalam B (1969) yang mendahului java dan threading hanya oleh sedikit.