Java menggunakan fungsi interrupted() kelas Thread untuk menentukan sama ada thread semasa terganggu.

Java menggunakan fungsi interrupted() kelas Thread untuk menentukan sama ada benang semasa terganggu

Dalam pengaturcaraan berbilang benang Java, gangguan ialah mekanisme komunikasi benang biasa. Utas boleh menghantar isyarat sampukan kepada urutan lain dengan memanggil kaedah interrupt(). Benang yang menerima isyarat gangguan boleh memutuskan cara untuk bertindak balas kepada gangguan. Kelas Thread dalam Java menyediakan kaedah interrupted() untuk menentukan sama ada thread semasa terganggu. Kaedah interrupt() 方法向另一个线程发送中断信号。接收到中断信号的线程可以决定如何响应中断。Java中的 Thread 类提供了 interrupted() 方法，用于判断当前线程是否被中断。

interrupted() 方法是一个静态方法，它返回一个布尔值。当调用该方法时，它会判断当前线程是否被中断，并且清除中断状态，也就是将中断状态重新设置为 false。如果线程在调用 interrupted() 方法之前被中断过，那么 interrupted() 方法会返回 true；否则，返回 false。

下面通过一个简单的示例来说明 interrupted() 方法的使用：

public class InterruptExample implements Runnable {

    public void run() {
        try {
            System.out.println("线程开始执行");
            for (int i = 1; i <= 10; i++) {
                System.out.println("执行第 " + i + " 次任务");
                Thread.sleep(1000);
                if (Thread.interrupted()) {
                    System.out.println("线程收到中断信号");
                    throw new InterruptedException();
                }
            }
        } catch (InterruptedException e) {
            System.out.println("线程被中断");
        } finally {
            System.out.println("线程结束执行");
        }
    }

    public static void main(String[] args) {
        Thread thread = new Thread(new InterruptExample());
        thread.start();
        try {
            Thread.sleep(5000);
            thread.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中，我们创建了一个实现了 Runnable 接口的类 InterruptExample。在 run() 方法中，我们使用一个循环来模拟线程执行的任务。每次任务执行完后，线程会通过 Thread.sleep() 方法暂停1秒钟。在每次任务执行之前，我们通过调用 Thread.interrupted() 方法来判断线程是否被中断，如果是，则抛出 InterruptedException 异常。

在 main() 方法中，我们创建了一个新的线程，并使用 start() 方法启动线程。然后，主线程暂停5秒钟，并调用 interrupt() 方法向新线程发送中断信号。通过这个示例，我们可以观察到以下几点：

1. 线程会在 run() 方法中执行10次任务。
2. 如果线程在执行任务期间被中断，它会立即停止执行并抛出 InterruptedException 异常。
3. 如果线程在调用 Thread.interrupted() 方法之前被中断，那么 Thread.interrupted() 方法会返回 true。
4. 调用 Thread.interrupted() 方法后，线程的中断状态会被重置为 false。

通过使用 interrupted() 方法，我们可以方便地判断当前线程是否被中断，并在适当的时候作出相应的处理。但需要注意的是，当线程被中断时，它不会立即停止执行，而是会等到下一个可中断的状态（如 wait()、sleep()、join()

interrupted() ialah kaedah statik yang mengembalikan nilai Boolean. Apabila kaedah ini dipanggil, ia akan menentukan sama ada rangkaian semasa terganggu dan mengosongkan status gangguan, iaitu, menetapkan semula status gangguan kepada palsu. Kaedah interrupted() mengembalikan benar jika urutan diganggu sebelum memanggil kaedah interrupted() jika tidak, ia mengembalikan false. 🎜🎜Berikut ialah contoh mudah untuk menggambarkan penggunaan kaedah interrupted(): 🎜rrreee🎜Dalam contoh di atas, kami mencipta kelas yang melaksanakan antara muka Runnable Contoh Interrupt. Dalam kaedah run(), kami menggunakan gelung untuk mensimulasikan tugasan yang dilakukan oleh benang. Selepas setiap tugasan dilaksanakan, urutan akan dijeda selama 1 saat melalui kaedah Thread.sleep(). Sebelum setiap tugasan dilaksanakan, kami menentukan sama ada urutan itu terganggu dengan memanggil kaedah Thread.interrupted() Jika ya, buang pengecualian InterruptedException. 🎜🎜Dalam kaedah main(), kami mencipta urutan baharu dan menggunakan kaedah start() untuk memulakan urutan. Kemudian, utas utama berhenti seketika selama 5 saat dan memanggil kaedah interrupt() untuk menghantar isyarat interrupt kepada thread baharu. Melalui contoh ini, kita boleh melihat perkara berikut: 🎜

1. Benang akan melaksanakan tugas 10 kali dalam kaedah run().
2. Jika benang diganggu semasa melaksanakan tugas, ia serta-merta menghentikan pelaksanaan dan membuang pengecualian InterruptedException.
3. Jika urutan diganggu sebelum memanggil kaedah Thread.interrupted(), maka kaedah Thread.interrupted() akan kembali benar.
4. Selepas memanggil kaedah Thread.interrupted(), status thread yang terganggu akan ditetapkan semula kepada false.

🎜Dengan menggunakan kaedah interrupted(), kita boleh menentukan dengan mudah sama ada urutan semasa terganggu dan mengendalikannya dengan sewajarnya apabila sesuai. Tetapi perlu diingat bahawa apabila benang diganggu, ia tidak akan menghentikan pelaksanaan serta-merta, tetapi akan menunggu sehingga keadaan terganggu seterusnya (seperti wait(), sleep() code >, <code>join()) akan berhenti apabila ia muncul. Oleh itu, apabila menulis kod berbilang benang, kita harus mereka bentuk logik pengendalian gangguan dalam benang secara munasabah untuk memastikan benang boleh berhenti dan melepaskan sumber dengan selamat. 🎜

Atas ialah kandungan terperinci Java menggunakan fungsi interrupted() kelas Thread untuk menentukan sama ada thread semasa terganggu.. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!