Vidage de thread Java

Le vidage des threads Java est défini comme le vidage de tous les threads de traitement en direct dans la mémoire de la pile ; cela peut jouer un rôle essentiel dans les artefacts pour diagnostiquer les utilisations du processeur telles que les pics, les blocages, les problèmes de mémoire, les applications qui ne répondent pas avec certains codes d'erreur par défaut, les temps de demande et de réponse et même si d'autres problèmes liés au système sont également calculés et liés au thread. messages de vidage basés sur le serveur d'applications, il sera configuré dans les fichiers de configuration du serveur, il est principalement recommandé pour plus d'un vidage de thread et au moins 10 threads de vidage utilisés à intervalles réguliers dans la JVM.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Syntaxe

Si nous utilisons le langage de programmation Java, il peut avoir des classes et des méthodes par défaut utilisées pour créer des applications Web plus sophistiquées. Ici, le thread dump sera analysé à l'aide des outils ici ; la syntaxe de base des vidages de thread Java est la suivante.

class className
{
public static void main(String[] args) throws Exception
{
Object o = new Object();
Object o1= new Object();
Thread t=new Thread(new DeadLockRunnable(o,o1));
t.sleep();
--some java code logics---
}
}

Les codes ci-dessus constituent la syntaxe de base pour créer le thread dump dans la mémoire de la pile à l'aide de concepts tels que le blocage, etc. De plus, nous pouvons utiliser certaines méthodes par défaut comme DeadLockRunnable, ManagementFactory.getThreadMXBean(); voici quelques méthodes pour réaliser le thread dump dans la pile de programmation.

Comment fonctionne le thread dump en Java ?

Dans les applications Java, nous avons utilisé les serveurs Web et les serveurs d'applications pour exécuter les applications dans les navigateurs et sur le bureau (s'il s'agit d'une application autonome). En raison des serveurs Web que nous avons utilisés pour accéder à des dizaines, voire des centaines de threads à traiter dans un grand nombre d'utilisateurs simultanés. Si supposons que l'application soit accessible par plus d'un utilisateur, c'est-à-dire que deux utilisateurs ou plus accèdent en même temps aux mêmes ressources, le conflit entre les deux threads est inévitable, et même parfois un blocage se produira. En fonction du serveur Web, le thread dump sera configuré comme par exemple ; Apache Tomcat configurera le thread dump en utilisant une option comme /logs/Catalina.out le fichier si nous ouvrons le fichier de configuration, nous serons configurés les codes java de sortie s'ils sont là dans les concepts multi-thread impliqués dans le application, le serveur renvoie les erreurs et les exceptions dans la trace de la pile.

Le thread dump a différents états pour indiquer si l'utilisateur de l'application est vivant ou non, sinon Keep-Alive-Timer est également un nom de thread ; cela doit être utilisé pour créer le thread KeepAliveCache, qui a été conçu pour un thread http vivant. Chaque thread créé à l'aide de la JVM depuis qu'il a été démarré après le démon de type thread, ce qui signifie qu'il ne pourra pas empêcher la JVM du dernier thread en cours d'exécution de s'arrêter à la fois sur la machine et dans les applications.

Certains états de thread les plus importants comme Runnable, Waiting/Timed_waiting et Blocked sont des états qui seront utilisés pour bloquer et attendre les threads si l'application ou le processus est en multi-threading, donc à chaque fois que le thread est créé. est automatiquement envoyé à l'interface Runnable, après quoi plusieurs métadonnées liées à la priorité du thread, y compris la priorité du thread OS si le thread qui exécute le thread est en mode exécutable, l'état de blocage est utilisé pour bloquer les threads si les applications sont en multi-thread après la fin de l'un des threads, l'autre thread est exécuté jusqu'à ce qu'il soit verrouillé, donc à l'aide de concepts tels que les blocs de threads synchronisés, etc. en utilisant ces concepts et leur instance, cela a été réalisé. L'état d'attente est le temps d'attente du thread qui est calculé et il a été stocké dans la mémoire du thread appelé pool de threads qu'il attendait pour fonctionner dans ces états.

Exemples de vidage de thread Java

Différents exemples sont mentionnés ci-dessous :

Exemple n°1

Code :

package com.first;
import java.net.ServerSocket;
import java.net.Socket;
public class Example {
public void run()
{
System.out.println("Multithreads names are : " + Thread.currentThread().getName());
}
public static void main(String[] args) throws Exception {
long waitingtimethread = 2000 * 30 * 2;
long startingthread = System.currentTimeMillis();
Thread t = new Thread();
t.start();
Thread.sleep(300);
t.run();
try (
ServerSocket s = new ServerSocket(3000);
Socket s1 = s.accept()
) {
Thread t1 = new Thread();
t1.start();
while (t1.isAlive()) {
if (demo(startingthread, waitingtimethread, t1)) {
t1.interrupt();
t1.join();
}
}
} catch (Exception e) {
System.err.println("The Excetion will be captured here."+e);
}
System.out.println("Multithreads names are : " + Thread.currentThread().getName());
System.out.println("We can check the daemon thread is used or not: "
+ Thread.currentThread().isDaemon());
}
static boolean demo(long startingthread, long waitingtimethread, Thread t1) {
return ((System.currentTimeMillis() - startingthread) > waitingtimethread) && t1.isAlive();
}
}

Sortie :

Exemple n°2

Code :

package com.first;
import java.net.ServerSocket;
import java.net.Socket;
public class Example {
static boolean demo(long startingthread, long waitingtimethread, Thread t1) {
return ((System.currentTimeMillis() - startingthread) > waitingtimethread) && t1.isAlive();
}
public static void main(String[] args) throws Exception {
long waitingtimethread = 2000 * 30 * 2;
long startingthread = System.currentTimeMillis();
Thread t = new Thread();
Thread t2 = new Thread();
t.start();
Thread.sleep(300);
t.run();
try (
ServerSocket s = new ServerSocket(3000);
Socket s1 = s.accept()
) {
Thread t1 = new Thread();
t1.start();
while (t1.isAlive()) {
if (demo(startingthread, waitingtimethread, t1)) {
t1.interrupt();
t1.join();
t1.notifyAll();
t2.notify();
}
}
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("Multithreads names are : " + Thread.currentThread().getName());
}
}

Sortie :

Exemple #3

Code :

package com.first;
public class Example extends Thread {
public void run()
{
System.out.println("Multithreads names are : " + Thread.currentThread().getName());
System.out.println("We can check the daemon thread is used or not: "
+ Thread.currentThread().isDaemon());
}
public static void main(String[] args)
{
Example e1 = new Example();
Example e2 = new Example();
e1.start();
e1.setDaemon(true);
e2.start();
}
}

Sortie :

Dans les trois exemples ci-dessus, nous avons utilisé différents scénarios pour les concepts de thread dump ; nous avons également utilisé différents types de méthodes de thread intégrées telles que notify(), Timed_Waiting(), sleep(); ces méthodes statiques simultanées réaliseront le vidage de plusieurs threads dans Java.

Conclusion

En général, les thread dumps sont un mécanisme utile pour les applications Web basées sur Java pour obtenir les rapports analysés détaillés. Cela inclut plusieurs utilisateurs accédant à l’application directement ou indirectement ; ces processus seront utiles pour résoudre les interruptions et augmenter les performances des applications.

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!