Plusieurs façons et exemples d'analyse de la terminaison du thread Java

Analyse des questions

La réponse est C

A : Le thread utilise la méthode sleep() pour suspendre le thread pendant un certain temps Le temps n'est pas une fin

B : Lors de la création d'un nouveau fil, cela n'a aucun impact sur le fil précédent

C : Une exception est levée et le le thread se termine

#🎜 🎜#D : Il ne s'agit pas d'une terminaison, mais d'une préemption. Le processus est l'unité la plus élémentaire d'allocation de ressources. Différents threads créés par le même processus partagent ces ressources. préemptera les ressources des autres threads, ce qui empêchera les autres threads de disposer de ressources, provoquant un blocage

Trois raisons pour la fin du fil

1. terminé et le fil se termine normalement

#🎜🎜 #2. Le fil renvoie une exception ou une erreur non interceptée

3. cela peut facilement conduire à une impasse)

Analyse détaillée

Trois façons de mettre fin à un fil de discussion

①Utilisez le bit de drapeau pour quitter le fil#🎜🎜 #

②Utilisez la méthode stop pour terminer de force le fil

# 🎜🎜#③Utilisez l'interruption pour terminer le fil

1 Utilisez le bit d'indicateur pour lancer le fil

.

En général, une fois la méthode run() exécutée, le thread se terminera normalement. Cependant, il y a souvent des threads qui sont le thread servo. Ils doivent fonctionner pendant une longue période, ils doivent donc utiliser une variable pour contrôler la boucle

définit un indicateur de sortie exit Lorsque exit est vrai, la boucle while se termine et la valeur par défaut de exit. est faux. Lors de la définition de exit , un mot-clé Java volatile est utilisé. Le but de ce mot-clé est de synchroniser exit. Un seul thread peut modifier la valeur de exit en même temps

public class ThreadSafe extends Thread {
  public volatile boolean exit = false; 
    public void run() { 
     while (!exit){
     //do something
     }
  } 
}

2. méthode stop pour terminer de force le thread#🎜 🎜#

Vous pouvez utiliser directement thread.stop() dans le programme pour terminer de force le thread, mais la méthode stop est très dangereuse, tout comme éteindre soudainement l'alimentation de l'ordinateur. En cas d'arrêt selon la procédure normale, des conséquences imprévisibles peuvent survenir. En conséquence, les principaux aspects dangereux sont les suivants : après l'appel de thread.stop(), le thread qui a créé le thread enfant générera une erreur ThreadDeatherror et libérera tous les verrous détenus. par le fil enfant.

3. Utilisez l'interruption pour terminer le fil

Lorsque le fil est dans deux états, utilisez l'interruption pour terminer

(1) Le fil est pas dans un état bloqué :

Utilisez isInterrupted() pour déterminer l'indicateur d'interruption du thread pour quitter la boucle. Lors de l'utilisation de la méthode interruption(), l'indicateur d'interruption sera défini sur true, ce qui est. la même chose que d'utiliser un indicateur personnalisé pour contrôler la boucle#🎜 🎜#

public class MyThread extends Thread {
    @Override
    public void run() {
        try {
            for (int i = 0; i < 500000; i++) {
                if (interrupted()) {
                    System.out.println("已经是停止状态了");
                    throw new InterruptedException();//中断异常
                }
                System.out.println("i=" + (i + 1));
            }
            System.out.println("我在for下面");
        } catch (InterruptedException e) {
            System.out.println("进run方法中的catch了！");
            e.printStackTrace();
        }
 
    }
}

(2) Le thread est dans un état bloqué : si la méthode sleep, attendez le verrouillage de synchronisation, le récepteur, acceptez et d'autres méthodes dans le socket sont utilisés, la méthode interruption() du thread s'appelle

public class ThreadInterrupt extends Thread {  
    public void run()  {  
        try {  
            sleep(50000);  // 延迟50秒  
        }  
        catch (InterruptedException e) {  
            System.out.println(e.getMessage());  
        }  
    }  
    public static void main(String[] args) throws Exception  {  
        Thread thread = new ThreadInterrupt();  
        thread.start();  
        System.out.println("在50秒之内按任意键中断线程!");  
        System.in.read();  
        thread.interrupt();  
        thread.join();  
        System.out.println("线程已经退出!");  
    }

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!