Kunci untuk mengelakkan kebuntuan Java adalah salah satu daripada empat syarat yang diperlukan untuk memecahkan kebuntuan. 1. Elakkan "Permintaan dan Pegang" Negeri. Anda boleh mencuba semula dengan memohon semua sumber sekaligus atau melepaskan sumber sedia ada, dan memastikan bahawa benang mengakses beberapa kunci dalam susunan yang sama; 2. Memperkenalkan urutan hierarki kunci, berikan nombor kepada setiap kunci dan memerlukan benang untuk mengunci perintah penomboran untuk mengelakkan gelung menunggu; 3. Gunakan kaedah reentRantLock.TryLock () untuk bekerjasama dengan mekanisme masa tamat untuk cuba memperoleh kunci dalam masa yang ditentukan, dan melepaskan kunci yang ada untuk mengelakkan menyekat jika gagal; 4. Gunakan JSTACK, VisualVM dan alat lain untuk mengesan kebuntuan yang berpotensi untuk membantu menyelesaikan masalah dan memantau penggunaan kunci.

Masalah kebuntuan di Java sering menyebabkan sakit kepala bagi pemaju, terutama dalam persekitaran berbilang threaded. Kunci untuk mengelakkan kebuntuan adalah memahami keadaan pembentukannya dan mengamalkan strategi yang sepadan . Senario kebuntuan yang sama adalah apabila pelbagai benang sedang menunggu sumber -sumber masing -masing yang dipegang oleh satu sama lain, menyebabkan program itu terjebak. Mari kita mulakan dari beberapa perspektif praktikal dan bercakap tentang bagaimana untuk mengelakkan lubang ini apabila menulis kod.

1. Elakkan status "permintaan dan tahan"

Ini adalah salah satu daripada empat syarat yang diperlukan untuk kebuntuan: benang tidak melepaskan sumber yang telah dipegangnya sambil menunggu sumber lain. Keadaan ini kemungkinan besar menyebabkan kebuntuan.

Penyelesaiannya adalah mudah: Memohon semua sumber yang diperlukan pada satu masa , atau jika anda tidak dapat memperoleh semua sumber, terlebih dahulu melepaskan sumber yang sedia ada dan cuba lagi.

Sebagai contoh, katakan anda mempunyai dua kunci lockA dan lockB , dan kedua -dua benang kunci dalam pesanan yang berbeza dengan mudah akan membawa kepada masalah:

 // Thread 1
disegerakkan (locka) {
    disegerakkan (lockb) {...}
}

// Thread 2
disegerakkan (lockb) {
    disegerakkan (locka) {...}
}

Dalam kes ini, benang boleh memegang salah satu kunci di antara satu sama lain dan kemudian terjebak menunggu kunci yang lain. Jadi:

• Semua benang cuba mengakses pelbagai sumber dalam susunan yang sama.
• Jika anda perlu mengambil beberapa kunci pada masa yang sama, anda boleh mempertimbangkan menggunakan kaedah ReentrantLock.tryLock() dan tetapkan masa tamat.

2. Perintah hierarki pengenalan kunci

Berikan setiap kunci "tahap" atau "nombor berurutan" kepadanya, yang memerlukan benang hanya mengunci dalam urutan nombor dari kecil ke besar, supaya tidak ada gelung menunggu.

Contohnya:

• Kunci nombor adalah 1
• Nombor kunci b ialah 2

Kemudian benang boleh mengunci pertama dan kemudian b, tetapi ia tidak boleh diterbalikkan. Jika modul melanggar peraturan ini, ia boleh didapati melalui pemeriksaan alat atau ujian unit.

Kelebihan kaedah ini ialah ia mempunyai struktur yang jelas dan penyelenggaraan yang mudah, dan sesuai untuk reka bentuk pengurusan sumber dalam projek sederhana dan besar.

3. Gunakan mekanisme tamat tempoh trylock

Java menyediakan kelas ReentrantLock , yang menyokong cuba mendapatkan kunci dan menetapkan masa tamat. Kaedah ini lebih fleksibel daripada synchronized tradisional dan secara berkesan dapat mengelakkan kebuntuan.

Kod sampel adalah seperti berikut:

 ReentrantLock locka = reentrantLock baru ();
ReentRantLock lockb = new reentRantLock ();

jika (locka.trylock (1, timeUnit.seconds)) {
    Cuba {
        jika (lockb.trylock (1, timeUnit.seconds)) {
            Cuba {
                // melakukan tindakan} akhirnya {
                lockb.unlock ();
            }
        }
    } akhirnya {
        locka.unlock ();
    }
}

Kod ini bermaksud:

• Cuba dapatkan kunci pertama pertama dan tunggu sebentar lagi.
• Selepas berjaya, cuba kunci kedua, dan tetapkan masa menunggu maksimum.
• Jika mana -mana yang gagal, kunci yang diperolehi secara automatik dikeluarkan, dengan itu mengelakkan kebuntuan.

Beberapa perkara untuk memberi perhatian ketika menggunakan tryLock :

• Menetapkan masa tamat masa yang sesuai terlalu pendek, yang mungkin gagal, dan terlalu lama akan kehilangan maknanya.
• Selepas operasi selesai, ingat untuk membuka kunci, sebaiknya letakkan di blok finally .

4. Ujian biasa dan bantuan alat

Walaupun banyak langkah pencegahan diambil, beberapa situasi mungkin terlepas kadang -kadang. Pada masa ini, anda boleh menggunakan beberapa alat untuk membantu menyelesaikan masalah risiko kebuntuan yang berpotensi.

JDK dilengkapi dengan beberapa alat, seperti:

• jstack : Cetak maklumat tumpukan thread, dan anda dapat melihat benang mana yang memegang kunci dan kunci yang sedang menunggu.
• VisualVM atau JConsole : Antara muka grafik boleh melihat status thread dan bahkan boleh terus memantapkan kebuntuan.

Di samping itu, beberapa logik pemantauan boleh ditambah semasa peringkat pembangunan, seperti perintah pengambilalihan dan pelepasan kunci rekod, dan analisis berkala boleh dilakukan.

Secara umum, Java Deadlock bukan masalah misteri. Selagi anda memberi perhatian kepada susunan aplikasi sumber, gunakan mekanisme kunci yang munasabah, dan periksa dengan alat, anda boleh mengurangkan kemungkinan kejadian.
Pada dasarnya itu sahaja.

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