Qu'est-ce qu'une interruption de thread ? Introduction détaillée à l'interruption des threads Java (avec exemples)

Cet article vous explique qu'est-ce qu'une interruption de fil de discussion ? L'introduction détaillée de l'interruption du thread Java a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer, j'espère qu'elle vous sera utile.

Tout le monde devrait être familier avec le code cassé ci-dessous. Thread Sleep doit intercepter ou lancer une exception d'interruption de thread, c'est-à-dire que quelqu'un se précipite soudainement et vous réveille pendant que vous dormez.

try {
    Thread.sleep(3000);
} catch (InterruptedException e) {
    e.printStackTrace();
}

Une fois le thread interrompu à ce moment, le code continuera à s'exécuter ou lancera une exception pour terminer l'opération. Ce n'est pas la fonction d'interrompre le thread dont nous avons besoin.

Qu'est-ce qu'une interruption de fil exactement ?

L'interruption du thread signifie que le thread est interrompu par d'autres threads pendant son exécution. La plus grande différence entre celui-ci et stop est que stop force le thread à être terminé par le système, tandis que l'interruption du thread envoie un signal d'interruption à. le thread cible. Si le thread cible ne reçoit pas le signal d'interruption du thread et ne termine pas le thread, le thread ne se terminera pas. Le fait de quitter ou d'exécuter une autre logique est déterminé par le thread cible.

Jetons un coup d'œil aux trois méthodes les plus importantes d'interruption de thread. Elles proviennent toutes de la classe Thread !

1. java.lang.Thread#interrupt

Interrompre le thread cible, envoyer un signal d'interruption au thread cible et le thread est marqué comme interrompu.

2. java.lang.Thread#isInterrupted()

Détermine si le thread cible est interrompu et la marque d'interruption ne sera pas effacée.

3. java.lang.Thread#interrupted

Pour déterminer si le thread cible a été interrompu, la marque d'interruption sera effacée.

Interruption de thread en action

Montrons comment utiliser l'interruption de thread avec un exemple !

Exemple 1 (échec de l'interruption)

/**
 * 微信公众号：Java技术栈
 */
private static void test1() {
    Thread thread = new Thread(() -> {
        while (true) {
            Thread.yield();
        }
    });
    thread.start();
    thread.interrupt();
}

Le fil de discussion de l'exemple 1 sera-t-il interrompu ? Réponse : Non, car même si un signal d'interruption est envoyé au thread, il n'y a aucune logique dans le programme pour répondre au signal d'interruption, donc le programme ne réagira d'aucune façon.

Exemple 2 : (Interruption réussie)

/**
 * 微信公众号：Java技术栈
 */
private static void test2() {
    Thread thread = new Thread(() -> {
        while (true) {
            Thread.yield();

            // 响应中断
            if (Thread.currentThread().isInterrupted()) {
                System.out.println("Java技术栈线程被中断，程序退出。");
                return;
            }
        }
    });
    thread.start();
    thread.interrupt();
}

Nous avons ajouté une logique pour répondre aux interruptions dans l'exemple 2. Le programme revient après avoir reçu le signal d'interruption et imprimé les informations.

Exemple 3 (échec de l'interruption)

/**
 * 微信公众号：Java技术栈
 */
private static void test3() throws InterruptedException {
    Thread thread = new Thread(() -> {
        while (true) {
            // 响应中断
            if (Thread.currentThread().isInterrupted()) {
                System.out.println("Java技术栈线程被中断，程序退出。");
                return;
            }

            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                System.out.println("Java技术栈线程休眠被中断，程序退出。");
            }
        }
    });
    thread.start();
    Thread.sleep(2000);
    thread.interrupt();
}

Exemple 3 La méthode sleep() a été interrompue et sortie Java技术栈线程休眠被中断，程序退出。 Le programme continue de s'exécuter... Pourquoi ?

Regardez le code source de sleep :

On peut voir que la méthode sleep() effacera la marque d'interruption après avoir été interrompue, la boucle continuera donc à s'exécuter. .

Exemple 4 (interruption réussie)

/**
 * 微信公众号：Java技术栈
 */
private static void test4() throws InterruptedException {
    Thread thread = new Thread(() -> {
        while (true) {
            // 响应中断
            if (Thread.currentThread().isInterrupted()) {
                System.out.println("Java技术栈线程被中断，程序退出。");
                return;
            }

            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                System.out.println("Java技术栈线程休眠被中断，程序退出。");
                Thread.currentThread().interrupt();
            }
        }
    });
    thread.start();
    Thread.sleep(2000);
    thread.interrupt();
}

L'exemple 4 affiche toutes les informations et se termine normalement, mais redémarre manuellement après l'interruption de la méthode sleep() et la marque est effacé Interrompre le thread en cours, puis le programme reçoit le signal d'interruption et revient pour quitter.

Grâce aux 4 exemples d'interruptions ci-dessus, je pense que vous avez une compréhension globale du concept d'interruptions de thread Java.

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!