Die Alibaba Cloud ARMS-Anwendungsüberwachung unterstützt Java 21

12.23 Yuanchuanghui·Shanghai Station, sprechen wir über die LLM-Infrastruktur

Autor: Mu Si & Shan Xie

Vorwort

Am 19. September dieses Jahres wurde Java 21, die neueste LTS-Java-Version (Long Term Support), offiziell veröffentlicht und bringt viele wichtige Updates mit sich. Weitere Informationen finden Sie unter The Arrival of Java 21 [ 1 ] . Obwohl Java 11 und Java 17 in China noch nicht weit verbreitet sind und Java 8 immer noch eine Mainstream-Position einnimmt, kann eine rechtzeitige Aktualisierung der JDK-Version den Entwicklern viele wichtige Vorteile bringen, einschließlich Verbesserungen der Anwendungsleistung und -stabilität. und neue Funktionen, die zur Steigerung der Produktivität beitragen können. Als einflussreichster Observable- und APM-Dienstleister in Asien reagierte das Alibaba Cloud ARMS-Team sofort auf die GA-Veröffentlichung von Java 21 und übernahm die Führung bei der Anpassung von Java 21, um Benutzern eine bessere Beobachtung von Java 21-Anwendungen zu ermöglichen!

Wichtige neue Funktionen von Java 21

Java 21 bringt 15 neue Funktionen, darunter virtuelle Threads, generationsübergreifendes ZGC und andere wichtige Funktionen sowie andere Optimierungen. Werfen wir einen kleinen Blick darauf und erleben Sie diese neuen Funktionen:

1. Virtueller Thread

Virtuelle Threads sind definitiv die wichtigste neue Funktion in Java 21. In früheren Java-Versionen entsprach jedes java.lang.Thread-Objekt nur einem Thread im Betriebssystemkernel, und Threads im Betriebssystem waren eine relativ teure Systemressource: Thread Erstellung, Wechsel, Zerstörung und andere Vorgänge erfordern den Eintritt in den Kernel-Status. Wenn in einem Szenario mit hoher Parallelität eine große Anzahl von Threads zur Verarbeitung von Anforderungen erstellt wird, werden mehrere Threads häufig angehalten und gewechselt, was Systemressourcen verbraucht.

Ein virtueller Thread ist ein leichter Benutzermodus-Thread. Im Gegensatz zu herkömmlichen Threads, die vom Betriebssystem geplant und ausgeführt werden, werden virtuelle Threads vom zugrunde liegenden JDK geplant und ausgeführt, und ihre Erstellung, Planung, Zerstörung und andere Vorgänge werden alle vom Benutzer durchgeführt -space-Bibliotheksfunktionen. Das heißt, die entsprechende Beziehung zwischen virtuellen Threads und Threads im Kernel ist M:N, wie in Abbildung 1 dargestellt:

Abbildung 1: Beziehungsdiagramm zwischen Threads und virtuellen Threads

Daher sind in Szenarien mit hoher Parallelität die Kosten für die Erstellung einer großen Anzahl virtueller Threads zur Verarbeitung von Anforderungen viel geringer als für die Erstellung einer großen Anzahl von Threads. In Java-Programmen ist der Vergleich zwischen Threads und virtuellen Threads in Tabelle 1 dargestellt:

Tabelle 1: Vergleichstabelle von Threads und virtuellen Threads

In Java 21 gibt es mehrere Möglichkeiten, virtuelle Threads zu erstellen und auszuführen:

// 方式一：
Thread vt = Thread.startVirtualThread(() -> {});
// 方式二:
Thread.ofVirtual().unstarted(() -> {});
vt.start();
// 方式三:
ThreadFactory tf = Thread.ofVirtual().factory();
Thread vt = tf.newThread(() -> {});
vt.start();
// 方式四:
ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
ThreadFactory tf = Thread.ofVirtual().factory();
Thread vt = tf.newThread(() -> {});
executor.submit(vt);

2. Generations-ZGC

In Java 21 wird Generationsunterstützung für ZGC (Generational ZGC) hinzugefügt, um die Leistung der Garbage Collection zu verbessern. Zuvor verfügte ZGC nicht über das Konzept der Generierung. Es sammelte bei jeder Ausführung alle Objekte, ohne das Alter der Objekte zu berücksichtigen. Nach der Theorie der Generationensammlung sind die meisten Objekte jedoch kurzlebig, und Objekte, die mehrere Speicherbereinigungsprozesse überstanden haben, werden schwieriger zu sterben sein. Das Bereinigen von Objekten der jungen Generation erfordert weniger Ressourcen und kann mehr Speicher freimachen; umgekehrt erfordert das Bereinigen von Objekten der alten Generation mehr Ressourcen und kann weniger Speicher freimachen. Dies bedeutet, dass ZGC die Effizienz der Garbage Collection basierend auf der Generations-Collection-Theorie weiter verbessern kann. Daher wurde in Java 21 der Generationssammlungsmechanismus eingeführt, um Objekte der jungen Generation häufiger zu sammeln, was sehr hilfreich ist, um die Leistung von Java-Anwendungen mit ZGC zu verbessern.

Um ZGC unter Java 21 zu verwenden, müssen Sie zunächst die Option -XX:+UseZGC zum Java-Startbefehl hinzufügen, um ZGC zu aktivieren. Nach dem Hinzufügen dieser Option ist standardmäßig nicht-generationelles ZGC aktiviert. Wenn Sie generationelles ZGC verwenden müssen, müssen Sie eine zusätzliche Option -XX:+ZGenerational hinzufügen.

# 使用分代式ZGC
$ java -XX:+UseZGC -XX:+ZGenerational ...

3. Weitere Funktionen

Neben virtuellen Threads und generationalem ZGC führt Java 21 auch weitere interessante Funktionen ein, wie zum Beispiel:

Es ist erlaubt, das Zeichen _ zu verwenden, um unbenannte Variablen zu deklarieren, ähnlich wie _ in der Go-Sprache.
Die Hauptmethode anonymer Klassen und anonymer Instanzen ist zulässig. Die Hauptfunktion kann wie unten gezeigt ausgeführt werden.

void main() {
    System.out.println("Hello, World!");
}

Weitere spezifische Funktionen finden Sie unter: openjdk.org/projects/jdk/21/ .

Überwachen Sie Java 21-Anwendungen mit ARMS

In der neuesten Version 3.1.0 der ARMS-Probe haben wir Java 21 unterstützt. Entwickler können diesen Artikel lesen, um die beobachtbare Reise von Java 21-Anwendungen zu beginnen.

Schreiben von Java 21-Anwendungen

Zuerst müssen Sie JDK 21 herunterladen und installieren. Sie können es von den offiziellen Websites von Herstellern wie Oracle oder über Tools von Drittanbietern wie sdkman herunterladen und installieren.

Nach der Installation von JDK 21 können Sie auf den folgenden Code zurückgreifen, um eine einfache SpringBoot 3.x-Anwendung zu schreiben, die die Record Patterns-Funktion von Java 21 nutzt, um Benutzern bei der Dekonstruierung von Datensatzobjekten in Java mit prägnanter Syntax zu helfen:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.0.6</version>
    <relativePath/> <!-- lookup parent from repository -->
  </parent>

  <groupId>xxx</groupId>
  <artifactId>xxx</artifactId>
  <version>xxx</version>
  <name>xxx</name>

  <properties>
    <java.version>21</java.version>
  </properties>


  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>

</project>

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

    record Point(int x, int y) {

    }

    @RestController
    static class DemoController {
        @RequestMapping("/demo")
        String demo(@RequestParam String type) {
            Object object = null;
            if ("record".equals(type)) {
                object = new Point(1, 2);
            } else {
                object = "object";
            }
            return solve(object);
        }

        private String solve(Object object) {
            if (object instanceof Point(int x, int y)) {
                return "Point: " + x + ":" + y;
            }
            return "Invalid Point";
        }
    }
}

Greifen Sie auf ARMS zu

Für Java-Anwendungen bietet ARMS eine Vielzahl praktischer Zugriffsmethoden. Informationen zum Zugriff finden Sie in der Übersicht über den Zugriff auf die Anwendungsüberwachung [ 2] . Für Anwendungen, die im Alibaba Cloud Container Service ACK [ 3] ausgeführt werden, können Sie die einfachste Zugriffsmethode verwenden: Implementieren Sie die automatische Injektion und Konfiguration von Sonden basierend auf dem Pilotmodus, ohne das Image zu ändern, und müssen Sie nur zwei Pods zum Yaml-Label der Anwendung hinzufügen Kann an ARMS angeschlossen werden.

Installieren Sie zunächst die ack-onepilot-Komponente für den ACK-Cluster, wie in Abbildung 2 dargestellt:

Abbildung 2: Installation von ack-onepilot

Erstellen Sie nach Abschluss der Installation eine Java-Anwendung im ACK-Cluster und fügen Sie die beiden Pod-Beschriftungen in Abbildung 3 zum Feld spec.template.metadata des Pods hinzu. Unter diesen stellt armsPilotCreateAppName den mit ARMS verbundenen Anwendungsnamen dar, der mit dem Bereitstellungsnamen übereinstimmen kann. ArmsPilotAutoEnable kann auf „Ein“ gesetzt werden. Sie können die Yaml-Datei des Deployments auch direkt bearbeiten, um Pod-Labels hinzuzufügen.

Abbildung 3: Tags hinzufügen

Nachdem die Anwendung erfolgreich bereitgestellt wurde, wird der ARMS-Konsolenlink auf der ACK-Konsole angezeigt, wie in Abbildung 4 dargestellt. Klicken Sie, um zur ARMS-Konsole zu springen.

Abbildung 4: Bedienoptionen der ARMS-Konsole

Nachdem Java die Anwendung gestartet hat, druckt die Anwendung auch das in Abbildung 5 gezeigte Protokoll, das angibt, dass die Anwendung den ARMS-Probe gemountet hat.

Abbildung 5: Startprotokoll der JDK21-Anwendung

Hinweis: Die Unterstützung von ARMS für Java 21 basiert auf der Versionsprüfung 3.1.0. Zum Zeitpunkt der Veröffentlichung dieses Artikels war die Versionsprüfung 3.1.0 noch nicht offiziell veröffentlicht. Sie können den QR-Code auf DingTalk scannen, um dem beizutreten ARMS unterstützt die Java 21-Erfahrungsgruppe, um Version 3.1.0 zu erhalten. Nachdem die Version 3.1.0 offiziell veröffentlicht wurde, können Sie die neueste Version der Sonde direkt von der offiziellen ARMS-Website herunterladen oder die Sonde der Version 3.1.0 automatisch über den Pilotmodus erhalten.

ARMS unterstützt Java 21. Experience DingTalk-Gruppennummer: 54565000535*

Überwachungsdaten anzeigen

Nachdem die Anwendung erfolgreich gestartet wurde, fordern Sie die /demo-Schnittstelle an und Sie erhalten die in Abbildung 7 gezeigte Antwort:

Abbildung 7: Antwort der /demo-Schnittstelle

Nachdem Sie die /demo-Schnittstelle angefordert haben, können Sie zur Anwendungslistenseite der ARMS-Konsole gehen und auf klicken, um die Anwendungsüberwachungsseite aufzurufen, wie in Abbildung 8 dargestellt, oder über die Übertragung auf der ACK-Konsole direkt zur ARMS-Konsole springen.

Abbildung 8: Anwendungsliste der ARMS-Konsole

Es ist ersichtlich, dass ARMS Java 21-Anwendungen erfolgreich identifiziert und relevante beobachtbare Daten gesammelt hat, wie in Abbildung 9-11 dargestellt. Diese Beobachtungsdaten können Benutzern helfen, schnell Einblick in die Systembetriebsbedingungen zu gewinnen, die Effizienz der Online-Fehlerbehebung zu beschleunigen und den Geschäftsbetrieb zu verbessern . Stabilität. Weitere wichtige Funktionen der ARMS-Anwendungsüberwachung, wie intelligente Erkenntnisse, Aufrufkettenanalyse und CPU- und Speicherdiagnose, finden Sie im Hilfedokument zur ARMS-Anwendungsüberwachung [ 4] .

Abbildung 9: Metainformationen der ARMS-Anwendung

Abbildung 10: Aufrufinformationen der ARMS-Anwendungsschnittstelle

Abbildung 11: ARMS sollte Übersichtsinformationen enthalten

Liste der neuen Funktionen der Sonden der ARMS 3.X-Version

Es verbessert die Abdeckung gängiger Open-Source-Frameworks erheblich und unterstützt vollständige zeitaufwändige Statistiken asynchroner Frameworks wie Reactor Netty und Vert. Bietet genauere und umfangreichere Indikatoren und Spannendaten. Einzelheiten finden Sie unter Java-Komponenten und Frameworks, die von ARMS unterstützt werden [ 5] .
Durch die Leistungsoptimierung wird der Anwendungszugriff leichter und weniger aufdringlich. Im 4C8G-Container-Szenario wird der durch das Mounten von Sonden verursachte zusätzliche CPU-Overhead im Vergleich zu früheren Versionen um 50 % reduziert, und der CPU-Overhead-Optimierungsbereich für Szenarien, die das asynchrone Framework verwenden, erreicht 65 % %, die Leistung ist besser; die Startzeit wird erheblich optimiert, die Startzeit für die Sondenmontage wird auf innerhalb von 5 Sekunden reduziert, und die Startzeit des Init-Containers wird durch den Containerzugriff auf 6 Sekunden verkürzt, und die Gesamtstartzeit der Sonde wird verkürzt Reduziert um 10 Sekunden+;
Unterstützt die Code-Hotspot-Funktion. Da das allgemeine Tracing-System nur Kernmethoden in Mainstream-Open-Source-Software-Frameworks vergraben kann, wird in der endgültigen Aufrufkette eine lange Zeitspanne angezeigt, wenn in der Geschäftslogik des Benutzers eine zeitaufwändige Position erscheint, die am Tracing-Vergrabungspunkt fehlt Es kann nicht der spezifischen Codeausführungsmethode entsprechen, was dazu führt, dass der Zeitverbrauch der Geschäftslogik nicht genau beurteilt werden kann.

Abbildung 12: Beispieldiagramm zur Tracing-Überwachung der Blindzone

Basierend auf dem branchenweit bekannten Open-Source-Tool Async Profiler [ 6] für die kontinuierliche Profilerstellung stellt die ARMS-Code-Hotspot-Funktion On- und Off-CPU-Flammendiagramme auf Aufrufkettenebene bereit, indem sie die TraceId- und SpanId-Informationen in der Aufrufkette korreliert Überwachen Sie Tracing effektiv. Details zu blinden Flecken werden wiederhergestellt, um Benutzern bei der Diagnose verschiedener häufiger Probleme mit langsamen Anrufketten zu helfen.