Gunakan disegerakkan untuk mengawal granulariti, gunakan blok kod yang disegerakkan terlebih dahulu; penggunaan kelas alat seperti reentrantlock dan concurrenthashmap dalam pakej java.util.concurrent; Elakkan kebuntuan dan gunakan trylock; Volatile boleh memastikan penglihatan yang berubah -ubah tetapi tidak menggantikan penyegerakan. Khususnya: 1. Apabila menggunakan disegerakkan, anda harus mengutamakan blok kod penyegerakan dan bukannya keseluruhan kaedah untuk mengunci sumber yang benar -benar perlu dilindungi; 2. Gunakan reentrantlock untuk menyediakan mekanisme kunci yang lebih fleksibel, ReadWriteLock meningkatkan prestasi Read More dan tulis kurang adegan, dan ConcurrentHashMap lebih cekap daripada SynchronizedMap; 3. 4. Volatile digunakan untuk memastikan penglihatan pembolehubah, dan sesuai untuk pembolehubah bendera negeri, tetapi ia bukan atom, dan perlu digunakan dengan kunci. Pilihan mekanisme penyegerakan yang munasabah dapat meningkatkan prestasi konkurensi dan memastikan keselamatan benang.

Mekanisme penyegerakan Java adalah cara utama untuk memastikan konsistensi data dan keselamatan benang dalam pengaturcaraan berbilang threaded. Jika anda tidak memberi perhatian kepada bagaimana anda menggunakannya, mudah untuk mempunyai kebuntuan, keadaan perlumbaan atau kesesakan prestasi. Berikut adalah beberapa cadangan dan amalan praktikal dalam pembangunan sebenar.

Kawalan granulariti semasa menggunakan kata kunci yang disegerakkan

synchronized adalah mekanisme penyegerakan yang paling asas di Jawa. Ia mudah digunakan tetapi mudah menyalahgunakan. Ramai orang suka secara langsung menambah synchronized kepada kaedah ini, tetapi ini boleh menyebabkan kunci menjadi terlalu besar dan menjejaskan prestasi konkurensi.

• Mengutamakan blok kod segerak ke atas keseluruhan kaedah, mengunci hanya sumber yang benar -benar perlu dilindungi.
• Jika pelbagai benang beroperasi pada keadaan objek yang berbeza, cuba elakkan menggunakan kunci peringkat kelas (seperti kaedah synchronized static ), jika tidak, penyumbatan yang tidak perlu mungkin berlaku.

Contohnya:

 public void addData (int value) {
    disegerakkan (datalist) {
        datalist.add (nilai);
    }
}

Ini lebih fleksibel dan lebih cekap daripada menulis public synchronized void addData(...) .

Mengutamakan penggunaan kelas alat dalam pakej java.util.concurrent

JDK5 memperkenalkan pakej java.util.concurrent , yang mengandungi banyak kelas alat konvensyen siap sedia, seperti ReentrantLock , ReadWriteLock , Semaphore dan pelbagai koleksi yang selamat.

• Reentrantlock menyediakan mekanisme kunci yang lebih fleksibel daripada synchronized , menyokong percubaan untuk memperoleh kunci, tamat masa, dll.
• ReadWriteLock dapat meningkatkan prestasi dalam senario di mana lebih banyak bacaan dan kurang menulis.
• Menggunakan ConcurrentHashMap bukan Collections.synchronizedMap() , ia mengoptimumkan pengoptimuman kunci segmen yang lebih halus.

Contohnya:

 REENTRANTLOCK LOCK Final Private = New ReentRantLock ();

public void dosomething () {
    lock.lock ();
    Cuba {
        // melaksanakan kod kawasan kritikal} akhirnya {
        lock.unlock ();
    }
}

Walaupun kod itu mempunyai beberapa baris lagi, ia lebih fleksibel dan sangat sesuai untuk logik penyegerakan kompleks.

Elakkan kebuntuan: perhatikan pesanan dan bersarang kunci

Deadlocks adalah salah satu masalah yang paling sukar dalam program berbilang threaded, biasanya kerana pelbagai benang meminta banyak kunci dalam pesanan yang berbeza.

• Perintah mengunci bersatu: Semua benang memohon kunci dalam susunan yang sama, yang dapat mengurangkan kebarangkalian kebuntuan.
• Cuba elakkan mendapatkan kunci lain sebelum ia dibebaskan.
• Anda boleh menggunakan tryLock() untuk menetapkan masa tamat masa. Jika anda tidak dapat mendapatkannya, lepaskan sumber yang sedia ada terlebih dahulu dan cuba lagi.

Contohnya:

 // amalan yang salah boleh menyebabkan thread deadlock1: locka -> lockb
Thread2: lockb -> locka

// Cara yang betul untuk melakukannya, menyatukan thread pesanan1 & thread2: locka -> lockb

Di samping itu, menggunakan alat seperti JStack atau VisualVM boleh membantu menganalisis keadaan benang dan segera mengesan masalah kebuntuan yang berpotensi.

Jangan abaikan peranan yang tidak menentu

volatile tidak menggantikan mekanisme penyegerakan, tetapi ia sangat berguna dalam beberapa kes. Ia memastikan keterlihatan pembolehubah, iaitu satu benang mengubah pembolehubah dan benang lain dapat melihat perubahan dengan segera.

• Berkenaan dengan pembolehubah bendera status, seperti mengawal sama ada benang terus dijalankan:

 Boolean yang tidak menentu peribadi berjalan = benar;

Semasa (berlari) {
    // buat sesuatu}

hentian void awam () {
    berjalan = palsu;
}

Sekiranya volatile tidak ditambah, pengubahsuaian berjalan dengan kaedah berhenti () mungkin tidak berkuatkuasa dengan segera, kerana benang itu boleh membaca nilai dari cache tempatan.

Walau bagaimanapun, perlu diperhatikan bahawa volatile tidak menjamin atomik, dan operasi seperti i masih perlu disiapkan dengan kunci.

Pada dasarnya itu sahaja. Mekanisme penyegerakan Java tidak kelihatan rumit, tetapi mudah untuk terjebak dalam penggunaan sebenar. Kuncinya adalah untuk memahami senario yang berkenaan setiap mekanisme dan memilih alat yang sesuai berdasarkan keadaan sebenar projek.

Atas ialah kandungan terperinci Amalan terbaik untuk mekanisme penyegerakan Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!