Java-Thread-Dump

Der Java-Thread-Dump ist als Dump aller Live-Verarbeitungsthreads im Stapelspeicher definiert; Es kann eine wichtige Rolle bei den Artefakten spielen, um die CPU-Auslastung wie Spitzen, Deadlocks, Speicherprobleme, nicht reagierende Anwendungen mit einigen Standardfehlercodes oder Anforderungs- und Antwortzeiten zu diagnostizieren, und obwohl auch einige andere systembezogene Probleme berechnet und mit dem Thread in Zusammenhang gebracht werden Dump-Meldungen basierend auf dem Anwendungsserver werden in den Serverkonfigurationsdateien konfiguriert. Es wird hauptsächlich für mehr als 1 Thread-Dump und mindestens 10 Dump-Threads empfohlen, die in regelmäßigen Abständen in der JVM verwendet werden.

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

Syntax

Wenn wir die Programmiersprache Java verwenden, kann diese über Standardklassen und -methoden verfügen, die zum Erstellen anspruchsvollerer Webanwendungen verwendet werden. Hier wird der Thread-Dump mit den Tools hier analysiert; Die grundlegende Syntax für die Java-Thread-Dumps lautet wie folgt.

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---
}
}

Die oben genannten Codes sind die grundlegende Syntax zum Erstellen des Thread-Dumps im Stapelspeicher mithilfe von Konzepten wie Deadlock usw. Darüber hinaus können wir einige Standardmethoden wie DeadLockRunnable, ManagementFactory.getThreadMXBean(); Dies sind einige Methoden, um den Thread-Dump im Programmierstapel zu erreichen.

Wie funktioniert Thread-Dump in Java?

In Java-Anwendungen haben wir die Webserver und Anwendungsserver zum Ausführen der Anwendungen sowohl in Browsern als auch auf dem Desktop (sofern es sich um eine eigenständige Anwendung handelt) verwendet. Aufgrund der Webserver, die wir für den Zugriff auf Dutzende bis Hunderte von Threads verwendet haben, um eine große Anzahl gleichzeitiger Benutzer zu verarbeiten. Wenn angenommen wird, dass mehr als ein Benutzer auf die Anwendung zugreift, d. h. zwei oder mehr Benutzer gleichzeitig auf dieselben Ressourcen zugreifen, ist ein Konflikt zwischen den beiden Threads unvermeidlich, und manchmal kommt es sogar zu einem Deadlock. Basierend auf dem Webserver wird der Thread-Dump wie folgt konfiguriert: Apache Tomcat konfiguriert den Thread-Dump mithilfe einer Option wie /logs/Catalina.out. Wenn wir die Konfigurationsdatei öffnen, werden die ausgegebenen Java-Codes konfiguriert, sofern sie in den beteiligten Multithreading-Konzepten vorhanden sind Anwendung wirft der Server die Fehler und Ausnahmen im Stack-Trace.

Der Thread-Dump hat verschiedene Zustände, um anzuzeigen, ob der Anwendungsbenutzer aktiv ist oder nicht. Ansonsten ist Keep-Alive-Timer auch ein Thread-Name; Dies sollte zum Erstellen des KeepAliveCache-Threads verwendet werden, der für einen lebenden http-Thread in Ordnung war. Jeder einzelne Thread, der mit der JVM erstellt wurde, seit er nach dem Thread-ähnlichen Daemon gestartet wurde. Dies bedeutet, dass er nicht verhindern kann, dass die JVM des zuletzt ausgeführten Threads sowohl auf der Maschine als auch in den Anwendungen heruntergefahren wird.

Einige der wichtigsten Thread-Zustände wie „Runnable“, „Waiting/Timed_waiting“ und „Blocked“ sind einige Zustände, die zum Blockieren und Warten auf die Threads verwendet werden, wenn sich die Anwendung oder der Prozess im Multithreading befindet, also immer dann, wenn der Thread erstellt wird Wird automatisch zur Runnable-Schnittstelle weitergeleitet, werden mehrere Metadaten zur Thread-Priorität angezeigt, einschließlich der Betriebssystem-Thread-Priorität, wenn der Thread, der den Thread ausführt, ausführbar ist. Der Blockierungsstatus des Modus wird verwendet, um die Threads zu blockieren, wenn sich die Apps nach Abschluss des Threads im Multithreading befinden Der eine Thread wird vom anderen Thread ausgeführt, bis dieser gesperrt ist. Mithilfe von Konzepten wie synchronisierten Thread-Blöcken usw. wurde dies mithilfe dieser Konzepte und ihrer Instanz erreicht. Der Wartestatus ist die berechnete Thread-Wartezeit und wird im Thread-Speicher namens Thread-Pool gespeichert, auf den er gewartet hat, um in diesen Zuständen zu funktionieren.

Beispiele für Java-Thread-Dump

Verschiedene Beispiele sind unten aufgeführt:

Beispiel #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();
}
}

Ausgabe:

Beispiel #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());
}
}

Ausgabe:

Beispiel #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();
}
}

Ausgabe:

In den obigen drei Beispielen haben wir unterschiedliche Szenarien für die Thread-Dump-Konzepte verwendet; Außerdem haben wir verschiedene Arten integrierter Thread-Methoden wie notify(), Timed_Waiting(), sleep(); Diese gleichzeitigen statischen Methoden ermöglichen den Dump mehrerer Threads in Java.

Fazit

Im Allgemeinen sind Thread-Dumps ein nützlicher Mechanismus für Java-basierte Webanwendungen, um detaillierte analysierte Berichte zu erhalten. Dazu gehört, dass mehrere Benutzer direkt oder indirekt auf die Anwendung zugreifen. Dieser Prozess wird hilfreich sein, um die Unterbrechungen zu beheben und die Leistung der Anwendungen zu steigern.

Das obige ist der detaillierte Inhalt vonJava-Thread-Dump. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!