Project Loom réduit le besoin de programmation réactive dans de nombreux cas en faisant des opérations de blocage bon marché via des threads virtuels, permettant un code simple et synchrone pour évoluer efficacement. 2. La programmation réactive reste pertinente pour la manipulation de la contre-pression, des flux de données à volume élevé ou infinis et une composition asynchrone complexe. 3. Les threads virtuels excellent dans les scénarios liés aux E / S avec code lisible, tandis que les modèles réactifs sont toujours préférés pour un contr?le à grain fin, un traitement de flux et des environnements sans métier à tisser. 4. Les deux peuvent coexister, avec des pipelines réactifs fonctionnant sur des threads virtuels ou en utilisant des planificateurs virtuels à dos de filetage, en combinant la simplicité et le contr?le. 5. L'avenir de la concurrence Java favorise le code de blocage simple par défaut, en utilisant des approches réactives uniquement lorsque leurs capacités avancées sont nécessaires, ce qui signifie que les bibliothèques réactives comme Reactor ou Webflux ne sont pas obsolètes mais doivent être utilisées judicieusement.

La programmation réactive en Java s'est traditionnellement comptabilisée sur des bibliothèques comme Project Reactor ou Rxjava pour gérer des opérations asynchrones et non bloquant, en particulier dans des scénarios à haute concurrence tels que les serveurs Web ou les systèmes axés sur les événements. Cependant, avec l'arrivée du métier à tisser et des fils virtuels dans Java 21, le paysage de la programmation simultanée change considérablement. Cela soulève une question importante: comment le métier à tisser a-t-il un impact sur la programmation réactive en Java?

La réponse courte: les threads virtuels réduisent le besoin de programmation réactive dans de nombreux cas d'utilisation courants , mais les modèles réactifs ont toujours leur place, en particulier lorsqu'ils traitent de la contre-pression, des flux de données complexes ou de la composition fonctionnelle.

Décomposons cela.

1. Quel problème a-t-il résolu la programmation réactive?

Avant le métier à tisser, gérer des milliers de demandes simultanées avec des E / S de blocage traditionnelles (par exemple, JDBC, Thread.sleep() ou bloquer les appels HTTP) était cher. Chaque thread a consommé une mémoire significative (pile de 1 Mo par défaut) et le système d'exploitation avait des limites sur le nombre de threads.

Des cadres réactifs comme Reactor et Webflux ont donc émergé:

• Utilisez des E / S non bloquantes et des boucles d'événements (comme Node.js).
• Partagez un petit nombre de fils sur de nombreuses taches.
• Traitez les données sous forme de flux avec des opérateurs comme map , filter , flatMap .
• Prise en charge de la contre-pression - les consommateurs peuvent contr?ler le taux de flux de données.

Ce modèle a bien fonctionné mais est venu avec la complexité:

• Courbe d'apprentissage abrupte.
• Débogage plus dur (les traces de pile sont fragmentées).
• Interopérabilité limitée avec les API de blocage.

2. Comment le métier à tisser change le jeu

Project Loom présente des threads virtuels - Threads légers gérés par le JVM, pas le système d'exploitation.

Avantages clés:

• Des millions de threads virtuels peuvent fonctionner efficacement.
• Chaque thread virtuel utilise beaucoup moins de mémoire (~ des centaines d'octets).
• Ils sont con?us pour bloquer à moindre co?t . Oui, le blocage est maintenant correct .

Exemple:

 ExecutorService exécutor = exécutor.NewVirtualThreadperTaskExECUTOR ();

IntStream.Range (0, 10_000) .ForEach (i -> {
    Executor.Submit (() -> {
        Thread.sleep (durée.Ofcondes (1));
        System.out.println ("Done:" i);
        retourner null;
    });
});

Cela engendre 10 000 fils virtuels qui dorment (bloc) sans tuer votre système. Avec les fils de plate-forme, cela échouerait ou ramperait.

Alors maintenant, au lieu d'écrire des cha?nes réactives complexes pour éviter le blocage, vous pouvez écrire du code simple et synchrone qui évolue.

3. Est-ce que cela rend la programmation réactive obsolète?

Pas entièrement. Voici où chaque approche brille:

? Utilisez des threads virtuels lorsque:

• Vous effectuez un travail lié aux E / S (par exemple, appels HTTP, opérations de fichiers).
• Vous voulez un code simple et lisible .
• Vous n'avez pas besoin d'une contre-pression ou d'un traitement de flux.
• Vous vous intégrez aux API de blocage (par exemple, JDBC traditionnel).

 void handlerequest () {
    var user = db.loadUser (); // Blocage
    var config = service.getConfig (); // bloquer http
    EmailService.Send (utilisateur, config);
}

Exécutez l'une de ces discussions virtuelles - aucun besoin de Mono , Flux ou d'enfer de rappel.

? Conserver la programmation réactive lorsque:

• Vous avez besoin d'une contre-pression (par exemple, producteur rapide, consommateur lent).
• Vous traitez des flux de données infinis ou à volume élevé .
• Vous voulez un contr?le à grain fin sur la planification et le filetage .
• Vous êtes dans un environnement où vous ne pouvez pas utiliser un métier à tisser (versions Java plus anciennes).
• Vous comptez sur des écosystèmes réactifs (par exemple, Spring Webflux, R2DBC).

Reactif excelle toujours dans la composition des opérations asynchrones et la gestion de l'utilisation des ressources sous une charge extrême.

4. Peuvent-ils travailler ensemble?

Oui - et parfois c'est la meilleure approche.

Vous pouvez exécuter un pipeline réactif dans un thread virtuel ou utiliser des threads virtuels comme cible d'exécution pour les taches réactives.

Par exemple:

 Mono.fromCallable (() -> Très-Fensive-BlockerOperation ())
    .Subscribeon (Reactor.Core.Scheduler.Schedulers.fromexEcutor (
        Exécuteurs.NewVirtualThreadperTaskExEcutor ()
    ));

Maintenant, votre flux réactif bénéficie d'un blocage bon marché via des fils virtuels.

Ou, utilisez le réacteur de projet avec des threads virtuels dans Spring Boot 6:

 @Haricot
planificateur public virtualthreadscheduler () {
    return schenelers.fromexEcutor (exécuteurs.NewVirtualThreadperTaskExEcutor ());
}

Alors:

 Mono. juste ("bonjour")
    .Publishon (VirtualThreadScheduler ())
    .map (ceci :: BlockingTransform)
    .s'abonner();

Ce modèle hybride vous donne le meilleur des deux mondes : le contr?le réactif du flux avec l'efficacité de la concurrence du métier.

Fin de compte

• Le métier à tisser ne tue pas la programmation réactive - elle redéfinit son r?le.
• Pour la plupart des applications de serveur conventionnelles , les threads virtuels rendent le code de blocage simple évolutif, réduisant le besoin de complexité réactive.
• La programmation réactive reste précieuse pour le traitement avancé de flux, la contre-pression et l'intégration avec les systèmes réactifs.
• L'avenir peut être "réactif en cas de besoin, simple par défaut".

Alors, devriez-vous arrêter d'utiliser Reactor ou WebFlux? Non, mais reconsidérez si vous les utilisez juste pour éviter l'épuisement des filetages. Avec un métier à tisser, ce problème est largement résolu.

Fondamentalement: écrivez d'abord le code simple. Atteindre réactif uniquement lorsque vous avez besoin de ses pouvoirs uniques.

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!