Kedua-dua masalah keselamatan benang yang tidak menentu dan disegerakkan di Java, tetapi fungsi mereka berbeza: 1. Volatile memastikan penglihatan pembolehubah, memastikan bahawa membaca dan menulis secara langsung berinteraksi dengan memori utama di bawah pelbagai threading, dan sesuai untuk senario membaca dan menulis satu-satunya seperti bendera status, tetapi tidak memberikan atomisitas; 2. Disegerakkan menyediakan atomik dan penglihatan, dan memastikan bahawa hanya satu benang yang melaksanakan blok kod pada masa yang sama melalui kunci mutex, yang sesuai untuk operasi komposit seperti kiraan; 3. Volatile tidak boleh menggantikan diselaraskan, dan untuk operasi bukan atom, kelas alat yang disegerakkan atau serentak seperti atomicInteger masih diperlukan. Pemilihan alat yang betul dapat memastikan keselamatan dan kecekapan benang.

Di Java, keselamatan benang adalah kritikal apabila pelbagai benang mengakses data bersama. Tanpa penyegerakan yang betul, program dapat menunjukkan tingkah laku yang tidak dapat diramalkan disebabkan oleh keadaan kaum, isu penglihatan, dan keadaan yang tidak konsisten. Dua alat utama untuk menguruskan keselamatan benang volatile dan synchronized . Walaupun kedua -duanya membantu dengan keserasian, mereka melayani tujuan yang berbeza dan tidak boleh ditukar ganti.

Mari kita pecahkan bagaimana setiap kerja, bila menggunakannya, dan masalah yang mereka selesaikan.

Apakah kata kunci volatile ?

Kata kunci volatile memastikan penglihatan perubahan kepada pembolehubah di seluruh benang. Apabila pemboleh ubah diisytiharkan volatile , ia memberitahu JVM:

• Menulis kepada pembolehubah ini segera dibuang ke ingatan utama.
• Bacaan pembolehubah ini selalu datang dari ingatan utama, bukan dari cache tempatan benang.

Ini menghalang benang daripada menggunakan nilai cache yang basi-isu biasa dalam persekitaran pelbagai threaded.

Contoh: Menggunakan volatile

 VolatileExample kelas awam {
    Boolean yang tidak menentu peribadi berjalan = benar;

    hentian void awam () {
        berjalan = palsu;
    }

    public void run () {
        Semasa (berlari) {
            // buat kerja
        }
        System.out.println ("Berhenti");
    }
}

Dalam contoh ini, satu panggilan benang run() dan panggilan lain stop() . Tanpa volatile , benang run() mungkin tidak pernah melihat nilai yang dikemas kini running kerana ia boleh di -cache dalam memori CPU. Dengan volatile , perubahan itu dijamin dapat dilihat.

Bilakah Menggunakan volatile

Gunakan volatile apabila:

• Pembolehubah dibaca dan ditulis oleh pelbagai benang.
• Pembolehubah tidak bergantung pada nilai sebelumnya (iaitu, tiada operasi kompaun seperti count ).
• Anda hanya memerlukan penglihatan , bukan atom.

? Jangan gunakan volatile untuk operasi seperti x - mereka bukan atom walaupun pembolehubah tidak menentu.

Apakah kata kunci synchronized ?

synchronized menyediakan kedua -dua pengecualian bersama (hanya satu benang yang boleh melaksanakan blok/kaedah pada satu masa) dan penglihatan (perubahan yang dibuat di dalam blok yang disegerakkan dapat dilihat oleh benang lain).

Ia boleh digunakan untuk:

• Kaedah contoh (kunci pada contoh)
• Kaedah statik (kunci pada objek kelas)
• Blok kod (dengan objek kunci yang ditentukan)

Contoh: Menggunakan synchronized

 kaunter kelas awam {
    kiraan int swasta = 0;

    Peningkatan Kekosongan Segereh Public () {
        kiraan; // Operasi atom disebabkan oleh penyegerakan
    }

    Int GetCount yang disegerakkan awam () {
        kiraan pulangan;
    }
}

Di sini, synchronized memastikan bahawa hanya satu benang yang dapat melaksanakan increment() atau getCount() pada satu masa, menghalang keadaan kaum pada count .

Bagaimana synchronized memastikan penglihatan

Apabila benang memasuki blok synchronized , ia memperoleh kunci monitor dan:

• Memancarkan cache tempatannya.
• Muat semula pembolehubah dari memori utama.

Apabila ia keluar, ia menulis perubahan kembali ke ingatan utama. Jadi, seperti volatile , ia menjamin penglihatan - tetapi dengan atom yang ditambah.

Perbezaan Utama: volatile vs synchronized

Perangkap biasa dan amalan terbaik

• ? Gunakan volatile untuk bendera negeri (contohnya, shutdownRequested , initialized ).
• ? Gunakan synchronized apabila anda memerlukan atomik (contohnya, kenaikan, mengemas kini pelbagai pembolehubah).
• ? Jangan menganggap volatile membuat operasi kompaun selamat.
• ? Elakkan terlalu banyak synchronized - ia boleh menyebabkan pertikaian dan mengurangkan prestasi.

Contoh: Mengapa volatile tidak cukup untuk count

 kelas awam badcounter {
    kiraan int volatile peribadi = 0;

    kenaikan void awam () {
        kiraan; // bukan atom: baca, kenaikan, tulis
    }
}

Walaupun count volatile , count melibatkan tiga langkah. Dua benang boleh membaca nilai yang sama, yang membawa kepada kemas kini yang hilang. Anda perlu synchronized atau AtomicInteger .

Alternatif: AtomicInteger , ReentrantLock , dll.

Untuk prestasi dan fleksibiliti yang lebih baik, pertimbangkan:

• AtomicInteger , AtomicLong , dan lain -lain - Menyediakan operasi atom tanpa menyekat.
• java.util.concurrent.locks.ReentrantLock - Lebih banyak kawalan daripada synchronized .

Contoh dengan AtomicInteger :

 kiraan atomicInteger swasta = AtomicInteger baru (0);

kenaikan void awam () {
    Count.IncrementAndget (); // benang-selamat dan cekap
}

Ringkasan

• Gunakan volatile untuk bendera bersama mudah di mana anda memerlukan penglihatan tetapi tidak atom.
• Gunakan synchronized apabila anda memerlukan kedua -dua atomik dan penglihatan , terutamanya untuk operasi kompaun.
• Memahami bahawa volatile tidak menggantikan synchronized - mereka menyelesaikan bahagian -bahagian yang berlainan dari teka -teki konvensional.

Keselamatan Thread bukan sekadar menghalang kemalangan - ia mengenai memastikan ketepatan di bawah akses serentak. Memilih alat yang betul (kelas volatile , synchronized , atau atom) menjadikan kod anda selamat dan cekap.

Atas ialah kandungan terperinci Keselamatan Thread di Java: Panduan untuk `Volatile` dan` Disegerakkan`. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!