Explication détaillée de la méthode d'interruption du fil

Comment mettre en pause un autre thread dans un thread？
Il n'est pas recommandé ici d'utiliserstopMéthodes,UtiliserstopMéthode bien que vous puissiez forcer un thread en cours d'exécution ou en attente,Mais utiliserstopC'est dangereux..stop La méthode tue vraiment le thread,Si le thread verrouille la ressource partagée,Alors quand il a été tué, il n'y a plus de chance de libérer la serrure, Aucun autre thread ne sera jamais en mesure d'obtenir la serrure

On peut utiliserinterruptMéthodes.En utilisant cette méthode,Ce n'est pas commestop.La méthode interrompt un thread en cours d'exécution,Mais le thread va continuer;Mais l'état d'interruption du thread est défini,Est défini àtrue,Le thread détecte ce marqueur d'interruption de temps en temps,Pour déterminer si le fil doit être interrompu（L'état d'interruption esttrue）

public class test2 {
    
    public static void main(String[] args) {
    
        try {
    
            test2();
        } catch (InterruptedException e) {
    
            e.printStackTrace();
        }
    }
    private static void test2() throws InterruptedException {
    
        Thread t2 = new Thread(()->{
    
            while(true) {
    
                Thread current = Thread.currentThread();
                boolean interrupted = current.isInterrupted();
                System.out.println(interrupted);
                // Décidez vous - même s'il faut arrêter l'opération sur place 
                if(interrupted) {
    
                    System.out.println(interrupted);
                    break;
                }
            }
        }, "t2");
        t2.start();
        // Laissez le fil principal dormir 
        Thread.sleep(500);
        t2.interrupt();
    }
}

Résultats obtenus：

Mais quand nous interrompons Congestion（sleep,wait,join） Ce thread va produire un InterruptedExceptionAnomalie, Fin de l'exécution du thread . Mais si l'exception est saisie par le thread , Le thread peut encore décider du traitement ultérieur （Fin de l'opération,Continuez à courir, Faire des travaux de postcure, etc ）, Et ce thread dans le blocage de rupture va Réinitialiser l'état de l'étiquette à false;

@Slf4j
public class test1 {
    
    public static void main(String[] args) throws InterruptedException {
    
        TwoParseTermination twoParseTermination = new TwoParseTermination();
        twoParseTermination.start();
        Thread.sleep(3500);
        twoParseTermination.stop();
    }
}
@Slf4j
class TwoParseTermination {
    
    private Thread monitor;
    // Démarrer le thread
    public void start() {
    
        monitor = new Thread(() -> {
    
            while (true) {
    
                //Obtenir le thread actuel
                Thread thread = Thread.currentThread();
                if(thread.isInterrupted()) {
     // Appelez isInterrupted Obtenir la valeur de l'étiquette   Celui - ci n'effacera pas la marque 
                    System.out.println("Je m'occupe des affaires ...");
                    break;  //Fil de terminaison
                } else {
    
                    try {
    
                        Thread.sleep(1000);
                        System.out.println(" Effectuer des fonctions de surveillance  ...");
                    } catch (InterruptedException e) {
    
                        System.out.println("Définir les marqueurs de rupture ...");
                        // Parce que la valeur de l'étiquette est devenue false, Encore une interruption , C'est comme casser ce fil en cours d'exécution , Donc la valeur de l'étiquette ici est redevenue ture, Si cette valeur n'est pas réinitialisée ici, le thread fonctionnera toujours 
                        thread.interrupt();
                        e.printStackTrace();
                    }
                }
            }
        }, "monitor");
        monitor.start();
    }
    // Fil de terminaison
    public void stop() {
    
        monitor.interrupt();
    }
}

À propos deisInterrupted()EtInterrupted()Méthodes
Les deux méthodes peuvent déterminer l'état de rupture du fil courant ,La différence est que：

interrupted()C'est une méthode statique, Et réinitialisera l'état d'interruption du fil courant （Toujoursfalse）.EtisInterrupted() Ne pas réinitialiser l'état actuel

public class test2 {
    
    public static void main(String[] args) {
    
        Thread thread = new Thread(new Runnable() {
    
            @Override
            public void run() {
    
                try {
    
                    Thread.sleep(100 * 1000);
                } catch (InterruptedException e) {
    
                    e.printStackTrace();
                }
            }
        });
        thread.start();
        thread.interrupt();
        Thread.currentThread().interrupt();
        System.out.println("Première fois"+Thread.interrupted());
        System.out.println("Deuxième fois"+Thread.interrupted());
    }
}

Ici, nousinterruptC'estmainThread,Appelezinterrupted() La méthode sera réinitialisée à false