Un: pourquoi voulez-vous parler de capture anormale multi-thread à seule?
Regardez d'abord un exemple:
Classe publique ThreadException implémente Runnable {@Override public void run () {lancez new RuntimeException ();}: la console a imprimé une information anormale pendant une période de temps. L'instruction d'exécution du thread est placée dans le bloc de couple d'essai, il n'y a pas d'aide.Une anomalie du temps d'exécution a été lancée manuellement dans la course. Le résultat en cours est comme indiqué ci-dessous:
Il a été constaté que les anomalies ont été jetées dans la console et que les déclarations du bloc de capture n'ont pas été imprimées.
Conclusion: L'opération multipliée ne peut pas gérer les anomalies dans le processus d'exécution des anomalies dans l'ordre. Échappements anormaux, la tâche est hors de la tâche.
Donc, nous devons réfléchir à la façon de capturer des anomalies dans les multiples-threads?
2. Capture des anomalies dans plusieurs
Suivons les étapes ci-dessous pour terminer l'expérience:
1. Définissez le processeur d'exception
Nécessite de mettre en œuvre la méthode Ungaughtexception de Thread.UncaultExceptionHandler, comme suit: comme suit:
/ * * 1ère étape: Définissez le "processeur anormal" qui est conforme à la spécification du processeur anormal du fil * Real.UncaughtexceptionHandler Spécifications * / class MyUnCaugeptionHandler implémente le gestionnaire {/ * * Thread.UncaughtexceptionHandler.Uncaughtexception () sera fileté la capture de l'anomalie s'appelle quand il est presque mort * / @Override public void Ungaughtexception (thread t, jetable e) {System.out.println ("capturé" + e);}}}2. Définissez l'usine de threads en utilisant ce processeur anormal
/ ** Étape 2: Définissez le thread Factory * Thread Factory pour attacher la tâche au thread et lier un thread à un processeur anormal * / class HanlderThreadFactory implémente ThreadFactory {@Override public ThreadRead (Exécuter Nable R) {System. Println (this + "Création du thread"); = "+ T.getuncaughtexcegeptionler ()); return t;}}3. Définissez une tâche pour le laisser lancer une exception
/ * * Étape 3: Notre tâche peut lancer une exception. ;
4. Appelez l'expérience
/ ** Étape 4: Utilisez une usine de threads pour créer un pool de threads et appelez sa méthode d'exécution * / classe publique ThreadExceptionUngaughTexceptionHandler {public static void main (String [] args) {exécuteur vice exec = exécutor.newcachedThreadpool (new HanLDTyReadFactory () );Le résultat en cours est comme indiqué ci-dessous:
3. Conclusion
Pour capturer les anomalies générées par des threads multi-thread en Java, vous devez personnaliser un processeur anormal et le définir sur l'usine de threads correspondante (c'est-à-dire les première et deuxième étapes).
Quatrièmement, développez
Si vous savez que le même processeur anormal sera utilisé partout dans le code, la manière plus simple est de définir un domaine statique dans la classe de threads et de définir ce processeur sur le processeur insatisfaisant par défaut.
Ce processeur est appelé uniquement sans le processeur insatisfaisant approprié sans threads.
Public static void main (String [] args) {thread.setDefaultUngaughTexceptionHandler (new MyUnCaugexceptionHandler ());Ce qui précède est tout le contenu de la capture anormale du multi-étage multi-thread multi-thread de Java.