Bagaimana untuk mencegah dan menangani kebuntuan dalam pengaturcaraan serentak Java?

Kebuntuan ialah masalah biasa dalam pengaturcaraan serentak dan boleh dicegah atau ditangani dengan mengambil langkah-langkah: Mencegah kebuntuan: - Dapatkan kunci mengikut urutan - Elakkan menunggu bulat - Gunakan mekanisme tamat masa - Gunakan struktur data tidak menyekat untuk mengendalikan kebuntuan: - Pengesanan kebuntuan -Pemulihan jalan buntu-Cuba semula operasi

Pencegahan dan pengendalian jalan buntu dalam pengaturcaraan serentak Java

Kebuntuan ialah masalah biasa yang mungkin dihadapi dalam pengaturcaraan serentak, yang menyebabkan berbilang benang menunggu antara satu sama lain Membebaskan sumber, menyebabkan sistem kepada kebuntuan. Di Jawa, kebuntuan boleh dicegah atau dikendalikan dengan mengambil langkah yang sesuai.

Cegah kebuntuan

• Peroleh kunci mengikut tertib: Tentukan pesanan untuk sumber boleh diakses dan pastikan semua rangkaian memperoleh kunci dalam susunan ini. Sebagai contoh, jika utas A perlu mengakses sumber X dan Y, dan utas B perlu mengakses sumber Y dan Z, maka semua utas harus terlebih dahulu memperoleh kunci pada X dan kemudian kunci pada Y.
• Elakkan menunggu dalam bulatan: Pastikan benang tidak cuba mendapatkan kunci lagi sementara menunggu benang lain melepaskan kunci. Sebagai contoh, jika utas A sedang menunggu utas B melepaskan kunci pada sumber X, utas A tidak seharusnya cuba mendapatkan kunci pada X sekali lagi.
• Gunakan mekanisme tamat masa: Tetapkan tamat masa untuk benang memperoleh kunci. Jika benang tidak dapat memperoleh kunci dalam masa yang ditentukan, ia harus melepaskan kunci dan mencuba kaedah lain.
• Gunakan struktur data tidak menyekat: Menggunakan struktur data tidak menyekat seperti ConcurrentHashMap boleh mengurangkan kemungkinan kebuntuan. Struktur data ini membenarkan benang mengakses data secara serentak tanpa menggunakan kunci. .

Pemulihan Kebuntuan: Setelah kebuntuan dikesan, sistem boleh dipulihkan dengan melepaskan sumber terkunci atau mengganggu salah satu utas yang terlibat dalam kebuntuan.

Cuba Semula Kebuntuan:

Selepas melepaskan atau mengganggu sumber, anda boleh mencuba semula pelaksanaan, yang mungkin mengelakkan kebuntuan daripada berlaku lagi.

• Kes Praktikal
• Pertimbangkan coretan kod Java berikut:

  public class DeadlockExample {
  
      private final Object lock1 = new Object();
      private final Object lock2 = new Object();
  
      public void method1() {
          synchronized (lock1) {
              System.out.println("Thread " + Thread.currentThread().getName() + " acquired lock1");
              try {
                  Thread.sleep(1000);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
              synchronized (lock2) {
                  System.out.println("Thread " + Thread.currentThread().getName() + " acquired lock2");
              }
          }
      }
  
      public void method2() {
          synchronized (lock2) {
              System.out.println("Thread " + Thread.currentThread().getName() + " acquired lock2");
              try {
                  Thread.sleep(1000);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
              synchronized (lock1) {
                  System.out.println("Thread " + Thread.currentThread().getName() + " acquired lock1");
              }
          }
      }
  
      public static void main(String[] args) {
          DeadlockExample deadlockExample = new DeadlockExample();
  
          Thread thread1 = new Thread(deadlockExample::method1);
          Thread thread2 = new Thread(deadlockExample::method2);
  
          thread1.start();
          thread2.start();
      }
  }

Dalam contoh ini, dua utas (benang1 dan utas2) disegerakkan menggunakan lock1 dan lock2 masing-masing. Memandangkan kedua-dua benang memperoleh kunci dalam susunan terbalik, mereka menunggu antara satu sama lain untuk melepaskan kunci, mengakibatkan kebuntuan.
• Untuk mengelakkan kebuntuan, kami boleh mengubah suai kod untuk memperoleh kunci mengikut tertib:

  public class DeadlockExample {
  
      private final Object lock1 = new Object();
      private final Object lock2 = new Object();
  
      public void method1() {
          synchronized (lock1) {
              System.out.println("Thread " + Thread.currentThread().getName() + " acquired lock1");
              try {
                  Thread.sleep(1000);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
              synchronized (lock2) {
                  System.out.println("Thread " + Thread.currentThread().getName() + " acquired lock2");
              }
          }
      }
  
      public void method2() {
          synchronized (lock2) {
              System.out.println("Thread " + Thread.currentThread().getName() + " acquired lock2");
              synchronized (lock1) {
                  try {
                      Thread.sleep(1000);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
                  System.out.println("Thread " + Thread.currentThread().getName() + " acquired lock1");
              }
          }
      }
  
      public static void main(String[] args) {
          DeadlockExample deadlockExample = new DeadlockExample();
  
          Thread thread1 = new Thread(deadlockExample::method1);
          Thread thread2 = new Thread(deadlockExample::method2);
  
          thread1.start();
          thread2.start();
      }
  }

Dengan mengubah suai kod, kami memastikan thread1 dan thread2 sentiasa memperoleh kunci dalam susunan yang sama (kunci1 kemudian kunci2), sekali gus mengelakkan kebuntuan.

Atas ialah kandungan terperinci Bagaimana untuk mencegah dan menangani kebuntuan dalam pengaturcaraan serentak Java?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!