Que fait java.lang.Thread.interrupt() ?

Question

Pourriez-vous expliquer ce que `` fait lorsqu’elle est appelée ?

Answer 1

Thread.interrupt() définit l'état d'interruption/drapeau de la thread cible. Le code s'exécutant dans ce thread cible PEUT interroger l'état d'interruption et de gérer de manière appropriée. Certaines méthodes bloc comme Object.wait() peut consommer de l'état d'interruption immédiatement et de lever une exception appropriée (habituellement InterruptedException)

Interruption de Java n'est pas de préemption. Mettre une autre manière, les deux threads doivent coopérer afin de traiter l'interruption correctement. Si le thread cible n'interroge pas l'état d'interruption de l'interruption est effectivement ignorée.

L'interrogation se fait par l' Thread.interrupted() méthode qui renvoie le thread courant de l'état d'interruption ET efface d'interruption de drapeau. Habituellement, le thread peut faire quelque chose comme jeter InterruptedException.

EDIT (de Thilo commentaires): Certaines méthodes de l'API ont construit dans la gestion des interruptions. Du haut de ma tête cela comprend.

• Object.wait()/Thread.sleep()
• La plupart des java.util.concurrent des structures
• Java NIO (mais pas java.io) et de ne PAS utiliser InterruptedException, au lieu d'utiliser ClosedByInterruptException.

EDIT (de @thomas pornin's réponse pour exactement la même question pour l'exhaustivité)

Fil interruption est une façon douce de pousser un thread. Il est utilisé pour donner des threads une chance de sortir proprement, par opposition à l' Thread.stop() c'est plus comme tirer sur le fil avec un fusil d'assaut.

Answer 2

Qu'est-ce que l'interruption ?

Une interruption est une indication d'un thread qu'il devrait arrêter ce que c'est faire et faire autre chose. C'est pour le programmeur de décider exactement comment un thread répond à une interruption, mais il est très commun pour le thread pour résilier.

Comment est-il mis en œuvre ?

L'interruption mécanisme est mis en œuvre à l'aide d'un indicateur interne connu comme le interruption d'état. Invoquant Fil de discussion.interrompre définit cet indicateur. Lorsque un thread vérifie une interruption en l'invocation de la méthode statique Fil de discussion.interrompu, d'interrompre le statut de est désactivée. Le non-statique Fil de discussion.isInterrupted, qui est utilisé par un seul thread à la requête de l'interruption le statut de l'autre, ne change pas le interruption de l'indicateur d'état.

Dit - Fil.interruption de l'API:

Les interruptions de ce fil. D'abord l' méthode checkAccess de ce fil invoqué, ce qui peut provoquer une SecurityException à être jetés.

Si ce thread est bloqué dans un l'invocation de l'wait(), wait(long), ou wait(long, int) méthodes de la La classe d'objet, ou de la jointure(), join(long), join(long, int), sleep(long) ou sleep(long, int), les méthodes de cette classe, son interrompre le statut sera effacée et il recevra un InterruptedException.

Si ce thread est bloqué dans un I/O opération sur un interruptible le canal et le canal sera fermé, le fil d'interruption du statut sera réglé, et le fil recevoir un ClosedByInterruptException.

Si ce thread est bloqué dans un Sélecteur alors le fil de l'interrompre le statut sera défini et il sera de retour immédiatement à partir de la sélection l'opération, éventuellement avec un zéro valeur, comme si le sélecteur de réveil méthode a été invoquée.

Si aucune des conditions précédentes maintenez puis ce thread interruption le statut sera défini.

Check this out pour la compréhension complète sur :

http://download.oracle.com/javase/tutorial/essential/concurrency/interrupt.html

Espérons que cela devrait être utile

Answer 3

Si le thread est en attente (en appelant wait(), ou de certaines autres méthodes qui font essentiellement la même chose, comme sleep()), il sera interrompu, ce qui signifie qu'il cesse d'attendre pour ce qu'il était en attente et recevoir une InterruptedException à la place.

Il est tout à fait le fil lui-même (le code qui a appelé wait()) de décider quoi faire dans cette situation. Il n'est pas automatiquement la fin du thread.

Il est parfois utilisé en combinaison avec une résiliation du pavillon. Lorsqu'il est interrompu, le thread puisse vérifier ce drapeau, et puis arrête de lui-même. Mais encore une fois, c'est juste une convention.

Answer 4

Pour être complet, en plus des autres réponses, si le thread est interrompu avant qu'il bloque sur Object.wait(..) ou Thread.sleep(..) etc., c'est l'équivalent d'être interrompu immédiatement sur le blocage de cette méthode, comme le montre l'exemple suivant.

public class InterruptTest {
    public static void main(String[] args) {

        Thread.currentThread().interrupt();

        printInterrupted(1);

        Object o = new Object();
        try {
            synchronized (o) {
                printInterrupted(2);
                System.out.printf("A Time %d\n", System.currentTimeMillis());
                o.wait(100);
                System.out.printf("B Time %d\n", System.currentTimeMillis());
            }
        } catch (InterruptedException ie) {
            System.out.printf("WAS interrupted\n");
        }
        System.out.printf("C Time %d\n", System.currentTimeMillis());

        printInterrupted(3);

        Thread.currentThread().interrupt();

        printInterrupted(4);

        try {
            System.out.printf("D Time %d\n", System.currentTimeMillis());
            Thread.sleep(100);
            System.out.printf("E Time %d\n", System.currentTimeMillis());
        } catch (InterruptedException ie) {
            System.out.printf("WAS interrupted\n");
        }
        System.out.printf("F Time %d\n", System.currentTimeMillis());

        printInterrupted(5);

        try {
            System.out.printf("G Time %d\n", System.currentTimeMillis());
            Thread.sleep(100);
            System.out.printf("H Time %d\n", System.currentTimeMillis());
        } catch (InterruptedException ie) {
            System.out.printf("WAS interrupted\n");
        }
        System.out.printf("I Time %d\n", System.currentTimeMillis());

    }
    static void printInterrupted(int n) {
        System.out.printf("(%d) Am I interrupted? %s\n", n,
                Thread.currentThread().isInterrupted() ? "Yes" : "No");
    }
}

Sortie:

$ javac InterruptTest.java 

$ java -classpath "." InterruptTest
(1) Am I interrupted? Yes
(2) Am I interrupted? Yes
A Time 1399207408543
WAS interrupted
C Time 1399207408543
(3) Am I interrupted? No
(4) Am I interrupted? Yes
D Time 1399207408544
WAS interrupted
F Time 1399207408544
(5) Am I interrupted? No
G Time 1399207408545
H Time 1399207408668
I Time 1399207408669

Implication: si vous boucle suivante, et l'interruption se produit au moment précis où le contrôle a laissé Thread.sleep(..) et est en cours autour de la boucle, l'exception est quand même se produire. Donc, il est parfaitement sûr de compter sur le InterruptedException être fiable jeté après que le thread a été interrompu:

while (true) {
    try {
        Thread.sleep(10);
    } catch (InterruptedException ie) {
        break;
    }
}