Java utilise la fonction interrompue() de la classe Thread pour déterminer si le thread en cours est interrompu.

Java utilise la fonction interrompue() de la classe Thread pour déterminer si le thread actuel est interrompu

Dans la programmation multi-thread Java, l'interruption est un mécanisme de communication de thread courant. Un thread peut envoyer un signal d'interruption à un autre thread en appelant la méthode interrupt(). Le thread qui reçoit le signal d'interruption peut décider comment répondre à l'interruption. La classe Thread en Java fournit la méthode interrupted() pour déterminer si le thread actuel est interrompu. La méthode 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() est une méthode statique qui renvoie une valeur booléenne. Lorsque cette méthode est appelée, elle déterminera si le thread actuel est interrompu et effacera l'état d'interruption, c'est-à-dire réinitialisera l'état d'interruption sur faux. La méthode interrupted() renvoie true si le thread a été interrompu avant d'appeler la méthode interrupted() sinon, elle renvoie false ; 🎜🎜Ce qui suit est un exemple simple pour illustrer l'utilisation de la méthode interrupted() : 🎜rrreee🎜Dans l'exemple ci-dessus, nous avons créé une classe qui implémente l'interface Runnable Exemple d'interruption. Dans la méthode run(), nous utilisons une boucle pour simuler les tâches effectuées par le thread. Après l'exécution de chaque tâche, le thread sera mis en pause pendant 1 seconde via la méthode Thread.sleep(). Avant l'exécution de chaque tâche, nous déterminons si le thread est interrompu en appelant la méthode Thread.interrupted(). Si c'est le cas, levons une exception InterruptedException. 🎜🎜Dans la méthode main(), nous créons un nouveau fil et utilisons la méthode start() pour démarrer le fil. Ensuite, le thread principal fait une pause pendant 5 secondes et appelle la méthode interrupt() pour envoyer un signal d'interruption au nouveau thread. A travers cet exemple, nous pouvons observer les points suivants : 🎜

1. Le thread exécutera la tâche 10 fois dans la méthode run().
2. Si un thread est interrompu lors de l'exécution d'une tâche, il arrête immédiatement l'exécution et lève une exception InterruptedException.
3. Si le thread est interrompu avant d'appeler la méthode Thread.interrupted(), la méthode Thread.interrupted() retournera true.
4. Après avoir appelé la méthode Thread.interrupted(), l'état interrompu du thread sera réinitialisé à false.

🎜En utilisant la méthode interrupted(), nous pouvons facilement déterminer si le thread actuel est interrompu et le gérer en conséquence, le cas échéant. Mais il convient de noter que lorsqu'un thread est interrompu, il n'arrêtera pas l'exécution immédiatement, mais attendra le prochain état interruptible (comme wait(), sleep() code >, <code>join()) s'arrêtera lorsqu'il apparaîtra. Par conséquent, lors de l'écriture de code multithread, nous devons raisonnablement concevoir la logique de gestion des interruptions dans le thread pour garantir que le thread peut s'arrêter et libérer des ressources en toute sécurité. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!