Bagaimana untuk menyelesaikan masalah kebuntuan benang di Jawa

Cara menyelesaikan masalah buntu benang dalam Java

Pengenalan:
Berbilang benang digunakan secara meluas dalam program Java, yang boleh meningkatkan keselarasan dan prestasi program. Walau bagaimanapun, pengaturcaraan berbilang benang juga membawa beberapa masalah yang berpotensi, salah satu masalah yang paling biasa ialah kebuntuan benang. Artikel ini akan memperkenalkan konsep dan punca kebuntuan benang, dan menyediakan beberapa penyelesaian biasa, termasuk contoh kod khusus.

1. Apakah kebuntuan benang? Kebuntuan benang merujuk kepada masalah di mana dua atau lebih benang memegang kunci yang diperlukan oleh satu sama lain, menyebabkan semua benang tidak dapat meneruskan pelaksanaan. Apabila kebuntuan berlaku, program akan menunggu selama-lamanya dan hanya boleh diselesaikan dengan memulakan semula program. Kebuntuan benang adalah masalah tersembunyi yang kadangkala sukar dicari dan diselesaikan. . Jika satu utas menduduki sumber A dan satu lagi utas menduduki sumber B, dan kedua-duanya cuba memperoleh sumber yang diduduki oleh satu lagi, jalan buntu mungkin berlaku.

Minta dan tahan: Satu utas sudah menyimpan beberapa sumber dan terus menduduki sumber asal sambil meminta sumber lain, menyebabkan utas lain tidak dapat memperoleh sumber yang diperlukannya.

Menunggu bulatan: Berbilang utas membentuk pergantungan bulat, dan setiap utas sedang menunggu urutan seterusnya melepaskan sumber, sekali gus jatuh ke dalam gelung yang tidak terhingga.

1. 3. Kaedah untuk menyelesaikan kebuntuan benang
2. Elakkan menggunakan berbilang kunci: Mengurangkan kemungkinan persaingan sumber antara benang adalah cara yang berkesan untuk menyelesaikan masalah kebuntuan. Kita boleh cuba mengelakkan berbilang benang bersaing untuk sumber yang sama pada masa yang sama dengan mereka bentuk program dengan sewajarnya. Sebagai contoh, anda boleh menggunakan struktur data selamat benang atau menggunakan kelas pengumpulan serentak dalam pakej java.util.concurrent dan bukannya operasi disegerakkan dan kunci eksplisit.
3. Pastikan kunci teratur: Apabila menggunakan berbilang kunci, pastikan urutan memperoleh kunci konsisten. Jika benang 1 perlu memperoleh kunci A dahulu, dan kemudian memperoleh kunci B, dan benang 2 perlu memperoleh kunci B terlebih dahulu, dan kemudian memperoleh kunci A, kebuntuan mungkin berlaku. Untuk mengelakkan situasi ini, anda boleh bersetuju bahawa benang akan memperoleh kunci dalam susunan bersatu.

Penantian tamat masa: Tetapkan masa tamat masa kunci Selepas menunggu lebih daripada tempoh masa tertentu, tinggalkan permintaan untuk kunci dan lakukan pemprosesan lain. Dengan menetapkan mekanisme tamat masa di mana kunci diperoleh, kebuntuan boleh dielakkan.

Pengesanan dan Pemulihan Jalan Mati: Alat tersedia untuk mengesan dan memulihkan daripada kebuntuan. Anda boleh melihat status benang melalui pembuangan benang atau menggunakan kelas alat yang disediakan oleh mesin maya Java untuk menentukan sama ada kebuntuan telah berlaku. Setelah kebuntuan berlaku, pelaksanaan program boleh disambung semula dengan mengganggu urutan dan melepaskan sumber.
2. Berikut ialah contoh kod khusus yang menunjukkan cara menggunakan tamat masa kunci menunggu untuk menyelesaikan masalah buntu benang:

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class DeadlockExample {
   private Lock lockA = new ReentrantLock();
   private Lock lockB = new ReentrantLock();

   public void execute() {
      Thread thread1 = new Thread(() -> {
         lockA.lock();
         try {
            Thread.sleep(1000);
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
         lockB.lock();
         System.out.println("Thread 1: Executing");
         lockA.unlock();
         lockB.unlock();
      });

      Thread thread2 = new Thread(() -> {
         lockB.lock();
         try {
            Thread.sleep(1000);
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
         lockA.lock();
         System.out.println("Thread 2: Executing");
         lockB.unlock();
         lockA.unlock();
      });

      thread1.start();
      thread2.start();
   }

   public static void main(String[] args) {
      DeadlockExample deadlockExample = new DeadlockExample();
      deadlockExample.execute();
   }
}

3. Dalam kod di atas, kami mencipta dua utas utas1 dan utas2, dan masing-masing menggunakan kunciA dan kunciB . Kami menambahkan pernyataan tidur pada proses pelaksanaan setiap utas untuk mensimulasikan proses urutan memproses tugas yang kompleks. Apabila anda melaksanakan kod ini, anda akan mendapati bahawa kebuntuan akan berlaku selepas program dilaksanakan untuk tempoh masa tertentu, menyebabkan atur cara tidak dapat meneruskan pelaksanaan.
4. Untuk menyelesaikan masalah ini, kami boleh menetapkan tamat masa untuk tempat kunci diperoleh. Berikut ialah kod yang diubah suai:

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class DeadlockExample {
   private Lock lockA = new ReentrantLock();
   private Lock lockB = new ReentrantLock();

   public void execute() {
      Thread thread1 = new Thread(() -> {
         if(lockA.tryLock()){
             try {
                Thread.sleep(1000);
             } catch (InterruptedException e) {
                e.printStackTrace();
             }
             if(lockB.tryLock()){
                System.out.println("Thread 1: Executing");
                lockB.unlock();
                lockA.unlock();
             } else {
                lockA.unlock();
                System.out.println("Thread 1 failed to get lockB");
             }
         } else {
             System.out.println("Thread 1 failed to get lockA");
         }
      });

      Thread thread2 = new Thread(() -> {
         if(lockB.tryLock()){
             try {
                Thread.sleep(1000);
             } catch (InterruptedException e) {
                e.printStackTrace();
             }
             if(lockA.tryLock()){
                System.out.println("Thread 2: Executing");
                lockA.unlock();
                lockB.unlock();
             } else {
                lockB.unlock();
                System.out.println("Thread 2 failed to get lockA");
             }
         } else {
             System.out.println("Thread 2 failed to get lockB");
         }
      });

      thread1.start();
      thread2.start();
   }

   public static void main(String[] args) {
      DeadlockExample deadlockExample = new DeadlockExample();
      deadlockExample.execute();
   }
}

Dalam kod yang diubah suai, kami menggunakan kaedah tryLock() untuk cuba memperoleh kunci Jika kunci tidak diperoleh dalam masa yang ditetapkan, kami melepaskan permintaan untuk kunci dan meneruskan untuk melaksanakan tugas lain beroperasi. Dengan menambahkan panggilan pada kaedah tryLock(), kami berjaya mengelakkan kebuntuan.

Kesimpulan:

Kebuntuan benang adalah salah satu masalah biasa dalam pengaturcaraan berbilang benang, tetapi melalui reka bentuk yang munasabah dan menambah penyelesaian yang sepadan, kami boleh menyelesaikan masalah kebuntuan benang dengan berkesan. Artikel ini menyediakan beberapa penyelesaian biasa, termasuk mengelakkan berbilang kunci, memastikan kunci teratur, menunggu tamat masa dan pengesanan dan pemulihan jalan buntu. Pada masa yang sama, contoh kod khusus diberikan untuk menunjukkan cara menggunakan tamat masa kunci menunggu untuk menyelesaikan masalah kebuntuan benang. Dalam pembangunan sebenar, kita harus memilih penyelesaian yang sesuai mengikut situasi khusus untuk memastikan operasi normal dan pengoptimuman prestasi program.

Atas ialah kandungan terperinci Bagaimana untuk menyelesaikan masalah kebuntuan benang di Jawa. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!