Cara membetulkan: Ralat Java Concurrency: Kebuntuan benang

Cara menyelesaikan: Ralat Java Concurrency: Deadlock Thread

Pengenalan:
Dalam pengaturcaraan serentak, kebuntuan benang adalah masalah yang sangat biasa. Apabila beberapa utas bersaing untuk mendapatkan sumber, kebuntuan mungkin berlaku jika utas menunggu antara satu sama lain untuk mengeluarkan sumber. Artikel ini akan memperkenalkan konsep kebuntuan benang, puncanya, dan cara menyelesaikan masalah ini.

1. Konsep kebuntuan benang
   Apabila beberapa utas menunggu antara satu sama lain untuk melepaskan sumber, semua utas tidak dapat meneruskan pelaksanaan, membentuk kebuntuan benang. Kejadian kebuntuan benang biasanya disebabkan oleh empat syarat berikut menjadi benar pada masa yang sama:
2. Syarat pengecualian bersama: sumber hanya dibenarkan untuk diakses oleh satu utas pada masa yang sama.
3. Minta dan tahan syarat: Walaupun thread menduduki sumber, ia juga meminta sumber diisi oleh thread lain.
4. Tiada syarat kekurangan: Sumber hanya boleh dikeluarkan oleh benang yang memilikinya, dan benang lain tidak boleh melucutkannya.
5. Keadaan menunggu gelung: Terdapat urutan menunggu urutan di mana setiap utas sedang menunggu urutan seterusnya mengeluarkan sumber.
6. Punca kebuntuan benang
   Kebuntuan benang biasanya disebabkan oleh sebab berikut:
7. Pertikaian sumber: Berbilang benang bersaing untuk sumber yang sama pada masa yang sama tanpa strategi penjadualan yang sesuai, mengakibatkan kebuntuan.
8. Kebuntuan susunan kunci: Benang memperoleh kunci dalam susunan yang berbeza, menyebabkan satu sama lain saling menunggu untuk melepaskan kunci.
9. Benang menunggu antara satu sama lain: Benang A menunggu benang B melepaskan kunci, dan benang B menunggu benang A melepaskan kunci, mengakibatkan kebuntuan.
10. Kaedah untuk menyelesaikan kebuntuan benang
    Untuk menyelesaikan masalah kebuntuan benang, kita boleh mempertimbangkan kaedah berikut:

3.1 Elakkan menunggu secara bulat
Menunggu bulat adalah salah satu punca utama kebuntuan benang. Untuk mengelakkan menunggu bulat, anda boleh menggunakan algoritma pengisihan sumber, yang memerlukan benang untuk memperoleh kunci dalam susunan tertentu dan melepaskan kunci dalam susunan yang sama. Ini menghapuskan kemungkinan menunggu dalam gelung.

3.2 Satukan susunan penguncian
Situasi biasa dalam kebuntuan benang ialah benang yang berbeza memperoleh kunci dalam susunan yang berbeza, mengakibatkan menunggu antara satu sama lain. Untuk menyelesaikan masalah ini, kita boleh menetapkan bahawa semua benang mesti memperoleh kunci dalam susunan yang sama. Ini dapat mengelakkan berlakunya kebuntuan urutan kunci.

3.3 Gunakan mekanisme tamat masa kunci
Dalam pengaturcaraan berbilang benang, mekanisme tamat masa kunci boleh digunakan untuk mengelakkan kebuntuan benang. Apabila benang cuba memperoleh kunci untuk lebih daripada had masa tertentu dan gagal memperoleh kunci, ia boleh memilih untuk berhenti mendapatkan kunci dan mencuba kaedah pemprosesan lain.

Berikut ialah kod sampel yang menggunakan mekanisme tamat masa kunci untuk mengelakkan kebuntuan benang:

public class DeadlockExample {
    private static Object lock1 = new Object();
    private static Object lock2 = new Object();

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (lock1) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock2) {
                    System.out.println("Thread 1");
                }
            }
        }).start();

        new Thread(() -> {
            synchronized (lock2) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock1) {
                    System.out.println("Thread 2");
                }
            }
        }).start();

        // 设置超时时间为2秒
        CompletableFuture<Object> future = CompletableFuture.supplyAsync(() -> {
            while (true) {
                if (Thread.holdsLock(lock1) && Thread.holdsLock(lock2)) {
                    return true;
                }
            }
        }).orTimeout(2000, TimeUnit.MILLISECONDS);
        try {
            future.get();
        } catch (TimeoutException e) {
            System.out.println("Deadlock detected!");
            // 执行适当的处理逻辑
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

4. Ringkasan
   Kebuntuan benang adalah salah satu masalah biasa dalam pengaturcaraan serentak. Untuk menyelesaikan masalah kebuntuan benang, kita boleh mengelakkan menunggu gelung, menyatukan urutan penguncian, dan menggunakan mekanisme tamat masa kunci. Melalui strategi dan cara teknikal yang sesuai, masalah yang disebabkan oleh kebuntuan benang dapat dielakkan dengan berkesan dan keteguhan serta prestasi program serentak dapat dipertingkatkan.

Atas ialah kandungan terperinci Cara membetulkan: Ralat Java Concurrency: Kebuntuan benang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!