La JEP 425 d'OpenJDK : proposition de fonctionnalité de threading virtuel (préversion) indique : la plate-forme Java introduira la fonctionnalité de threading virtuel (la coroutine tant attendue). Les threads virtuels sont des threads légers qui peuvent réduire considérablement la charge de travail d'écriture, de maintenance et d'observation des applications simultanées à haut débit.
Les développeurs Java se sont toujours appuyés sur les threads comme blocs de construction des applications serveur simultanées, où les instructions de chaque méthode sont exécutées dans un thread, et chaque thread fournit une pile pour stocker les variables locales et coordonner les appels de méthode, ainsi que la capture de contexte en cas de les erreurs. Les threads sont l'unité de simultanéité de Java et la base des outils Java : le débogueur parcourt les instructions des méthodes du thread et le profileur visualise le comportement de plusieurs threads.
Actuellement, le JDK implémente ses threads de plate-forme en tant qu'encapsuleurs pour les threads du système d'exploitation (OS), chaque instance du JDK est un thread de plate-forme, le thread de plate-forme exécute le code Java sur le thread du système d'exploitation sous-jacent et exécute le code Java pendant tout le cycle de vie de les threads de code Capture OS. Le nombre de threads de plate-forme est limité par le nombre de threads du système d'exploitation, et les threads du système d'exploitation sont coûteux et ne peuvent pas prendre trop de place. Par conséquent, l'approche actuelle du JDK en matière de threading limite le débit de ses applications bien en deçà de ce que le matériel prend en charge.
À propos des threads virtuels
Un thread virtuel java.lang.Threadest un thread qui exécute du code Java sur le thread du système d'exploitation sous-jacent (thread du système d'exploitation), mais ne capture pas les instances du thread du système d'exploitation pendant toute la durée de vie du code. Cela signifie que de nombreux threads virtuels peuvent exécuter du code Java sur le même thread de système d'exploitation, en le partageant efficacement.
Les threads virtuels sont une implémentation légère des threads fournis par le JDK plutôt que par le système d'exploitation, et sont une forme de threading en mode utilisateur . Les threads en mode utilisateur étaient appelés "threads verts" dans les premières versions de Java , lorsque le concept de threads du système d'exploitation n'était pas suffisamment mature et populaire, et tous les threads verts de Java partageaient un thread du système d'exploitation (planification M: 1), avec le thread concept Avec le développement de , le thread vert est finalement dépassé par le thread de plate-forme actuel et implémenté en tant que wrapper du thread du système d'exploitation (ordonnancement 1:1), tandis que le thread virtuel nouvellement introduit adopte l'ordonnancement M:N, dans lequel un grand nombre (M) de threads virtuels sont planifiés comme s'exécutant sur un plus petit nombre (N) de threads de système d'exploitation.
débit plus élevé
Les développeurs peuvent choisir d'utiliser des threads virtuels ou des threads de plate-forme, mais les threads virtuels fonctionnent mieux dans les applications serveur à haut débit. Par exemple, le code suivant qui dort pendant une seconde crée un grand nombre de threads virtuels. Le programme obtient d'abord un ExecutorService , qui crée un nouveau thread virtuel pour chaque tâche soumise, puis soumet 10 000 tâches et attend que toutes les tâches soient terminées :
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
IntStream.range(0, 10_000).forEach(i -> {
executor.submit(() -> {
Thread.sleep(Duration.ofSeconds(1));
return i;
});
});
} // executor.close() is called implicitly, and waitsLe matériel moderne peut facilement prendre en charge 10 000 threads virtuels exécutant simultanément ce code. Si le programme utilise un ExecutorService qui crée un nouveau thread de plate-forme pour chaque tâche, par exemple Executors.newCachedThreadPool() , il essaiera de créer 10 000 threads de plate-forme, ce qui signifie 10 000 threads de système d'exploitation, et le programme ne fonctionnera pas sur la plupart des opérations. Le système va s'écraser. Ou le programme utilise un ExecutorService qui obtient des threads de plate-forme à partir du pool, comme Executors.newFixedThreadPool(200), ce qui n'est pas beaucoup mieux. ExecutorService créera 200 threads de plate-forme pour ces 10 000 tâches à partager, les tâches s'exécuteront séquentiellement au lieu de simultanément, et le programme prendra beaucoup de temps pour se terminer.
Pour le programme ci-dessus, un pool avec 200 threads de plate-forme ne peut atteindre qu'un débit de 200 tâches par seconde, tandis que les threads virtuels peuvent atteindre un débit d'environ 10 000 tâches par seconde (après un préchauffage suffisant). De plus, si vous modifiez 10 000 en 1 000 000 dans le programme d'exemple, le programme soumettra 1 000 000 tâches, créera 1 000 000 threads virtuels exécutés simultanément et (après un préchauffage suffisant) atteindra un débit d'environ 1 000 000 tâches/seconde.
En résumé, les threads virtuels ne sont pas des threads plus rapides - ils n'exécutent pas le code plus rapidement que les threads de plate-forme. Ils existent pour fournir une échelle (débit plus élevé), pas de vitesse (latence plus faible).
Comment activer les threads virtuels ?
Les threads virtuels sont actuellement largement utilisés dans d'autres langages multithreads (tels que les coroutines en Go et les processus en Erlang, et sont également une fonctionnalité stable en C++), mais sont toujours une API de prévisualisation en Java et désactivés par défaut. Pour essayer cette fonctionnalité sur JDK XX, l'API d'aperçu doit être activée par :
- Compilez le programme avec javac --release XX --enable-preview Main.java et exécutez-le avec java --enable-preview Main
- Lorsque vous utilisez le lanceur de code source, exécutez le programme avec java --release XX --enable-preview Main.java
- Lorsque vous utilisez jshell, commencez par jshell --enable-preview
Plus d'informations sur les threads virtuels peuvent être trouvées dans le JDK d'OpenJDK numéro 8277131. La proposition a été créée le 15/11/2021 et est actuellement dans la première phase du processus JEP, et il faudra un certain temps avant une version stable.