Java InterruptedException

InterruptedException berlaku apabila urutan mungkin sedang tidur, menunggu atau sibuk dan terganggu sebelum atau semasa sesuatu aktiviti dijalankan. Kadangkala kaedah mungkin ingin menguji sama ada rangkaian semasa telah terganggu atau tidak. Jika ia telah diganggu, maka ia akan membuang pengecualian serta-merta. Jika tidak, ia akan berfungsi dengan cara ia berfungsi. Dalam topik ini, kita akan belajar tentang Java InterruptedException.

Mulakan Kursus Pembangunan Perisian Percuma Anda

Pembangunan web, bahasa pengaturcaraan, ujian perisian & lain-lain

Sintaks

Untuk menggunakan pengecualian, anda perlu menggunakan sintaks berikut:

if (Thread.interrupted ())  // Clears interrupted status!
throw new InterruptedException ();

Di sini kaedah InterruptedException () mencipta InterruptedException tanpa mesej terperinci di dalamnya sebagai parameter.

Tetapi jika ia dilemparkan seperti InterruptedException (String s), ia mencipta InterruptedException dengan beberapa butiran khusus. Dalam kaedah ini, s ialah mesej terperinci.

Bagaimanakah InterruptedException berfungsi dalam Java?

Di sini kita akan membincangkan aliran kerja InterruptedException. Di sini dalam kod berbilang benang, benang selalunya boleh menyekat; utas menjeda pelaksanaan sehingga beberapa syarat luaran dipenuhi, seperti:

• apabila kunci dilepaskan
• atau urutan lain menyelesaikan operasi
• dan juga, beberapa operasi I/O selesai

Di sini, rangkaian boleh terganggu. Apabila gangguan berlaku, ia menghentikan benang daripada melakukan jenis kerja biasa yang mereka lakukan. Tetapi tindak balas yang tepat kepada gangguan yang ditentukan bergantung pada keadaan utas dan kemudian cara urutan itu akan dilaksanakan seperti di bawah:

Kami akan mempunyai benang yang boleh digunakan untuk menyekat benang atau benang terdahulu yang ada. Apabila ini ditangkap, ia membuang InterruptedException. Jika tiada isu dan tiada benang terdahulu, maka benang itu meneruskan kerjanya. Apabila urutan menjumpai pengecualian, ia menetapkan status urutan terputus kepada benar. Benang akan meninjau kaedah checkInterrupted () pada selang masa yang tetap. Ini ialah cara pilihan yang benang itu dijangka berfungsi. Setelah proses selesai, barulah ada aktiviti pembersihan yang berlaku. Selepas pembersihan, pelaksanaan kemudiannya dihentikan. Ia membuang InterruptedException, jika ada dan jika tidak, ia diteruskan dengan aliran pelaksanaan biasa.

Sekiranya terdapat gangguan dalam proses di atas, proses itu tidak sepatutnya menutup benang dengan serta-merta. Ini kerana ia akan berada di tengah-tengah beberapa pengiraan, yang akan sentiasa berlaku dan oleh itu ia mesti menunggu.

Pembina

Pembina ialah objek Java yang membantu dalam memulakan objek atau kaedah yang baru dibuat. Ia adalah contoh Java yang tidak mempunyai sebarang jenis pulangan. Oleh kerana ini sepatutnya memulakan objek, ia mempunyai nama yang sama dengan kelas yang dimilikinya. Akibatnya, apabila objek dipanggil, pembina dipanggil secara automatik dan dimulakan. Di bawah ialah kaedah pembina.

InterruptedException ()

Di sini, kaedah ini mencipta pengecualian tanpa mesej di dalamnya. Contoh kelas InterruptedException sedang dibuat di sini. Dalam pembina ini, parameter mesej ditetapkan sebagai nol.

Contoh:

public InterruptedException () InterruptedException (String s)

Dalam kaedah kelas InterruptedException ini,  parameter sedang digunakan sebagai mesej tertentu dalam format rentetan. Di sini parameter rentetan menerangkan nama kelas yang melemparkan ralat.

Contoh pada InterruptedException

Sekarang kita akan melihat contoh di mana utas sedang diganggu:

// Java Program to check how
// interrupt () method  works
// simultaneously while a thread stops working
class CheckInterruption extends Thread {
public void run ()
{
try {
Thread.sleep (2000);
System.out.println ( "We are checking Interrupted Exception");
}
catch (InterruptedException e) {
throw new RuntimeException ( "Thread is" + "interrupted");
}
}
public static void main (String args[])
{
CheckInterruption t1 = new CheckInterruption ();
t1.start ();
try {
t1.interrupt ();
}
catch (Exception e) {
System.out.println ("Exception handled");
}
}
}

Output:

Kod di atas membantu kami memahami konsep Pengecualian Terganggu. Kami mempunyai kelas, CheckInterruption, yang memanjangkan kelas Thread Java. Ia kemudian mencari pengecualian dalam blok cuba. Jika terdapat pengecualian, ia ditangkap dalam blok tangkapan, dan output dipaparkan sebagai blok tangkapan. Ini adalah kes dalam contoh kami di mana gangguan ditangkap, dan output yang diperlukan dipaparkan. Tetapi program ini tidak selesai kerana blok tangkapan memanggil kaedah Pengecualian () yang terdapat di Jawa. Mari kita semak contoh di mana pengecualian ditangkap, kemudian urutan seterusnya bermula.

class CheckInterruptingThread2 extends Thread{
public void run (){
try{  Thread.sleep (1000);
System.out.println ("task");
}catch (InterruptedException e){
System.out.println ("Exception is handled "+e);  }
System.out.println ("thread is now in running state...");
}
public static void main (String args[]){
CheckInterruptingThread2 t1=new CheckInterruptingThread2 ();
t1.start ();
t1.interrupt ();
}
}

Output:

The above program uses a class that is again extending the Thread class in Java. In the try () block, we make the thread sleep for some time, and then the catch block catches the exception when it is encountered. Once it is handled, the message is printed, and then the interrupt () method is called, after which the next thread moves to the running state. The same is displayed after the method call is finished and the thread starts working.

How to avoid InterruptedException?

The solution to this exception is you can stop making use of thread.sleep () method. Instead of this method, the more efficient method will be SystemClock.sleep () method. Another replacement for the above-mentioned method can be using TimeCOunter, which will depend on the logic and code where it is being used. This can also be an optimal solution.

If at all you would still like to make use of thread.sleep () then it should be used as below.

try {
Thread.sleep ();
} catch (InterruptedException e) {
Thread.currentThread ().interrupt (); /* this line will see to it that Thread.interrupted () always returns true */
throw new RuntimeException (e);
}

Conclusion – Java InterruptedException

As the word exception suggests, it is a state which can be checked and allowed to pass in some cases. InterruptedException happens when a thread waits or sleeps, and other threads are interrupted and cannot proceed further. We can handle this exception by either using proper try-catch blocks or by avoiding the usage of the sleep () method.

Atas ialah kandungan terperinci Java InterruptedException. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!