Les fils virtuels de Java 21 améliorent considérablement les performances des applications à haut contrat. 1. Il gère des fils légers à travers JVM, ce qui facilite la fonctionnalité d'une autonomie d'effectuer des centaines de milliers de taches simultanées; 2. Il convient aux scénarios à forte intensité d'E / S tels que les services Web, les microservices et le traitement par lots; 3. Le code de blocage existant n'a pas besoin d'être réécrit, il ne doit être exécuté que dans des threads virtuels; 4. Il est recommandé d'utiliser StructuredTaskscope pour gérer les taches simultanées pour éviter les fuites des ressources; 5. Il ne convient pas aux taches à forte intensité de processeur, et les threads de plate-forme ou les flux parallèles doivent continuer à être utilisés; 6. Les cadres traditionnels tels que Spring Boot 6, TomCat et Jetty sont pris en charge et peuvent être activés via la configuration; 7. Notez que le blocage des appels tels que JDBC occupera le fil du transporteur et affectera la concurrence globale; 8. évitez de mettre en commun des fils virtuels, des abus de filetage et adoptez des journaux asynchrones pour des performances optimales. Une utilisation appropriée des threads virtuels améliorera considérablement le débit, réduira la latence et simplifiera le code.

L'introduction de fils virtuelles par Java 21 marque un tournant pour construire des applications à haute curances. Contrairement aux threads de plate-forme traditionnels (qui sont de niveau OS et co?teux à créer), les fils virtuels sont légers, gérés par le JVM, et facilitent considérablement les applications qui génèrent des milliers, voire des millions de taches simultanées, sans réécrire toute votre base de code.

Vous n'avez pas besoin de devenir un expert en concurrence du jour au lendemain, mais comprendre comment utiliser efficacement les fils virtuels est désormais essentiel pour les performances de Java modernes.

Quels sont les fils virtuels et pourquoi ils comptent

Les threads virtuels font partie du métier à tisser du projet, con?u pour simplifier la programmation simultanée en Java. Voici l'idée principale:

• Threads de plate-forme (l'ancienne fa?on): Chaque thread mappe 1: 1 à un thread OS. Créer trop de causes à une utilisation élevée de la mémoire et un commutation de contexte.
• Threads virtuels : de nombreux threads virtuels fonctionnent sur un petit nombre de threads de plate-forme sous-jacents. Le JVM gère la planification et la commutation efficaces.

? Avantage clé : vous pouvez désormais engendrer des centaines de milliers de threads sans écraser votre serveur.

Ceci est particulièrement utile pour:

• Applications E / S-HEAVY (serveurs Web, microservices)
• API qui appellent plusieurs services en aval
• Traitement par lots avec un parallélisme élevé

Et la meilleure partie? Votre code existant fonctionne souvent tel quel - vous avez juste besoin de l'exécuter sur un fil virtuel.

Comment utiliser les fils virtuels en pratique

L'utilisation de threads virtuels est étonnamment simple. Vous n'avez pas besoin de nouveaux frameworks ou d'API complexes - utilisez simplement Thread.startVirtualThread() ou de la concurrence structurée via StructuredTaskScope .

Option 1: utilisation directe avec startVirtualThread()

 Thread.startVirtualThread (() -> {
    System.out.println ("Exécution sur un thread virtuel:" Thread.currentThread ());
    // Simuler les E / S travail
    essayez {thread.sleep (1000); } catch (InterruptedException e) {}
    System.out.println ("fait");
});

Aucune piscine de fil nécessaire. Chaque appel engendre un nouveau fil virtuel.

Option 2: Utilisation StructuredTaskScope (recommandé)

Pour gérer plusieurs taches simultanées en toute sécurité, StructuredTaskScope garantit que toutes les taches enfants complètent (ou échouent), avec une annulation et une gestion des erreurs appropriées.

 try (var scope = new StructuredTasksCope.shutdownOnFailure ()) {
    var subTask1 = scope.Fork (() -> fetchuser (1));
    var subsask2 = scope.Fork (() -> Order (1));

    scope.join (); // attendez toutes les taches
    Scope.Throwiffailed (); // propager tout échec

    Utilisateur utilisateur = subTask1.get ();
    Order Order = subTask2.get ();
}

? Cela remplace les cha?nes CompletableFuture désordonnées et évite les fuites de ressources.

Quand utiliser des threads virtuels (et quand ne pas faire)

Tous les charges de travail ne bénéficient pas de threads virtuels. Connaissez le sweet spot:

? Utilisez des threads virtuels lorsque:

• Les taches passent du temps à attendre (E / S, appels réseau, requêtes de base de données)
• Vous avez des besoins élevés de parallélisme (par exemple, gérer les demandes HTTP 10K)
• Vous utilisez du code de blocage (comme Traditional InputStream , JDBC, etc.)

? évitez les travaux à forte intensité de processeur:

• Numéro Crunching
• Traitement d'image / vidéo
• Calculs lourds

Pourquoi? Les threads virtuels ne réduisent pas la charge du processeur. Pour les taches liées au processeur, respectez les flux parallèles ou les pools de threads de taille fixe comme ForkJoinPool .

? Règle de base: si votre fil attend principalement, les fils virtuels gagnent. S'il est occupé , respectez les fils de plate-forme.

Intégrer avec les cadres existants

Vous n'avez pas besoin d'attendre que les cadres "prennent en charge" les fils virtuels - beaucoup fonctionnent déjà de manière transparente.

Spring Boot (6)

Activer les threads virtuels dans application.properties :

 server.tomcat.threads.virtual.enabled = true

Ou personnaliser l'exécuteur:

 @Haricot
public taskexecutor virtualThreadExecutor () {
    var factory = exécuteurs.NewthreadperTaskExEcutor (thread.ofVirtual (). factory ());
    Renvoie un nouveau concurrentTasKexecutor (exécuteurs.
        Thread.ofvirtual (). Factory ()
    ));
}

Tomcat, jetée, réseau

Les versions récentes prennent en charge les threads virtuels comme mécanisme de gestion de la demande. Lorsqu'il est activé, chaque demande HTTP s'exécute sur son propre thread virtuel - plus d'étranglements de pool de fil.

AVERTISSEMENT JDBC

La plupart des pilotes JDBC bloquent et synchrones , ce qui peut lier les fils de transporteur. Alors que les threads virtuels aident, le véritable accès Async DB (comme R2DBC) est meilleur pour le débit maximal.

?? Les appels de blocage long (par exemple, les requêtes JDBC lentes) réduisent toujours la concurrence globale car elles se produisent le thread de plate-forme sous-jacent ("thread de transporteur").

Conseils de performance et pièges

Voici ce qu'il faut surveiller:

• Ne mettez pas en commun des fils virtuels : ils sont bon marché à créer. Utilisez newThreadPerTaskExecutor , pas des pools de threads fixes.
• évitez les abus de filetage : les threads virtuels peuvent créer des millions d'instances - le lancer de gros objets en ThreadLocal peut provoquer des problèmes de mémoire.
• Surveiller les threads des opérateurs : le JVM utilise un pool fixe de threads de plate-forme pour exécuter des threads virtuels. Si tous sont bloqués (par exemple, par JDBC lent), votre application cale.
• Utilisez la journalisation asynchrone : si votre framework de journalisation bloque les E / S, il vainc le but. Considérez les annexes asynchrones.

Fin de compte

Les fils virtuels de Java 21 ne sont pas seulement un ajustement de performances - ils sont un changement de paradigme dans la fa?on dont nous écrivons des applications simultanées.

Vous pouvez maintenant:

• écrivez un code simple, lisible et bloquant
• Gérer une concurrence massive avec un matériel minimal
• Réduire la réforme des cadres réactifs complexes (comme Reactor ou Rxjava) à moins que vous ayez besoin d'une contre-pression

Commencez par exécuter vos taches d'E / S de blocage existantes sur les threads virtuels. Mesurer la différence. Vous verrez probablement un débit plus élevé, une latence plus faible et un code plus simple .

Fondamentalement, si vous créez des applications Java c?té serveur en 2024 et que vous n'utilisez pas de threads virtuels, vous laissez les performances et la productivité des développeurs sur la table.

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!