Kunci untuk mengelakkan kebuntuan adalah untuk memahami syarat -syarat untuk kejadian mereka dan mengamalkan strategi yang sesuai untuk mengelakkan pengelakan, yang termasuk 4 kaedah berikut: 1. Menyatukan perintah mengunci untuk memastikan semua benang memperoleh kunci dalam susunan yang sama, dengan itu mengelakkan gelung menunggu; 2. Gunakan reentrantlock kunci yang jelas dan tetapkan masa tamat, cuba dapatkan kunci melalui kaedah trylock () untuk mengelakkan menunggu yang tidak terbatas; 3. Mengurangkan butiran dan skop penggunaan kunci, hanya kunci bahagian utama, cuba gunakan pembolehubah tempatan dan kelas pengumpulan serentak untuk mengurangkan kebarangkalian konflik; 4. Gunakan alat seperti JStack, VisualVM, dan lain -lain untuk mengesan potensi kebuntuan, dan segera mengenal pasti dan menyelesaikan masalah menyekat benang.

Dalam pengaturcaraan multithread Java, kebuntuan adalah masalah yang biasa tetapi mudah diabaikan. Ia biasanya berlaku apabila pelbagai benang sedang menunggu sumber masing -masing, menyebabkan program itu terjebak dan tidak dapat meneruskan pelaksanaan. Kunci untuk mengelakkan kebuntuan adalah untuk memahami keadaan di mana ia berlaku dan mengamalkan strategi yang sesuai untuk mengelakkan.

1. Elakkan mengunci bersarang (pesanan kunci)

Kebanyakan masalah kebuntuan timbul dari pelbagai benang yang memperoleh banyak kunci dalam pesanan yang berbeza. Sebagai contoh, jika benang A memperoleh kunci 1 terlebih dahulu dan kemudian kunci 2, dan Thread B memperoleh Lock 2 terlebih dahulu dan kemudian kunci 1, kebuntuan mungkin berlaku.

Penyelesaian: Perintah mengunci bersatu

Selagi semua benang memperoleh kunci dalam susunan yang sama, situasi menunggu gelung ini dapat dielakkan dengan berkesan. Sebagai contoh, ia ditetapkan bahawa kunci dengan nombor yang lebih kecil sentiasa diperoleh terlebih dahulu, dan kemudian kunci dengan bilangan yang lebih besar diperolehi.

Contohnya:

 // Thread 1
disegerakkan (locka) {
    disegerakkan (lockb) {
        // buat sesuatu
    }
}

// Thread 2 (jika ia juga dalam urutan yang sama, tidak akan ada konflik)
disegerakkan (locka) {
    disegerakkan (lockb) {
        // buat perkara lain
    }
}

Dengan cara ini, kedua-dua benang tidak akan mengalami silang silang, dengan itu mengelakkan kebuntuan.

2. Gunakan kunci yang jelas dan tetapkan masa tamat (cuba-dengan-masa)

Java menyediakan mekanisme kunci yang lebih fleksibel seperti ReentrantLock , yang menyokong cuba memperoleh kunci dan menetapkan masa tamat. Kaedah ini secara aktif dapat menyerah apabila kunci tidak diperoleh, dan bukannya menunggu selama -lamanya.

Amalan yang dicadangkan:

• Gunakan kaedah tryLock() dan bukannya synchronized
• Tetapkan masa menunggu yang munasabah untuk mengelakkan penyumbatan kekal

Contoh kod:

 ReentrantLock lock1 = reentrantLock baru ();
ReentrantLock lock2 = reentrantLock baru ();

Boolean Dibawa1 = lock1.TryLock ();
Boolean Dibawa2 = FALSE;

jika (diperolehi1) {
    Cuba {
        memperoleh2 = lock2.tryLock (500, timeUnit.Milliseconds);
    } akhirnya {
        jika (! Dibawa2) lock1.unlock ();
    }
}

Sekiranya kunci kedua tidak dapat diperoleh dalam masa yang ditentukan, anda boleh membebaskan sumber yang diperolehi dan cuba lagi atau keluar untuk mengelakkan diri daripada jatuh ke dalam keadaan kebuntuan.

3. Kurangkan skop kunci

Banyak kali, untuk kesederhanaan dan kemudahan, kami akan mengunci keseluruhan kaedah atau menggunakan pelbagai blok penyegerakan yang besar, yang bukan sahaja mempengaruhi prestasi, tetapi juga meningkatkan risiko kebuntuan.

Arah Pengoptimuman:

• Pindahkan kod yang tidak perlu disegerakkan dari blok penyegerakan
• Cuba gunakan pembolehubah tempatan dan bukannya sumber yang dikongsi
• Gunakan kelas pengumpulan serentak (seperti ConcurrentHashMap ) dan bukannya mengunci manual

Contohnya:

 // tidak disyorkan amalan disegerakkan void badmethod () {
    // melakukan banyak operasi yang tidak melibatkan sharedResource.dosomething ();
}

// kaedah penulisan yang lebih baik tidak sah lebih baik () {
    // Hanya mengunci bahagian utama yang disegerakkan (sharedResource) {
        sharedResource.dosomething ();
    }
}

Semakin kecil julat kunci, semakin pendek masa ia memegang kunci, semakin rendah kebarangkalian konflik.

4. Gunakan alat untuk mengesan

Walaupun anda telah berurusan dengan logik berbilang thread dengan teliti, mungkin ada ketinggalan. Pada masa ini, anda boleh menggunakan beberapa alat untuk membantu memeriksa potensi risiko kebuntuan:

• JVM dilengkapi dengan JSTACK TOOL : Ia boleh mencetak tumpukan thread untuk mengenal pasti benang yang sedang menunggu dan kunci yang mereka tunggu.
• VisualVM atau JConsole : Alat grafik yang boleh memantau status thread dalam masa nyata dan bahkan secara automatik mendorong untuk kebuntuan yang mungkin.
• Alat Analisis Plug-In atau Static IDE : Seperti fungsi analisis thread Intellij, juga boleh memberi petunjuk semasa peringkat pengekodan.

Jalankan contoh arahan:

 JStack <PID> | Grep -i Deadlock

Perintah ini dapat membantu anda dengan cepat mencari sama ada terdapat kebuntuan.

Pada dasarnya itu sahaja. Walaupun kebuntuan mungkin kelihatan agak rumit, selagi anda memberi perhatian kepada perintah penguncian, mengurangkan julat kunci, menggunakan kunci yang jelas, dan menggabungkan dengan penyelesaian masalah alat, ia dapat mengurangkan kebarangkalian kebarangkalian.

Atas ialah kandungan terperinci Bagaimana untuk mengelakkan kebuntuan dalam kesesuaian Java?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!