A Loom introduction, the new Java concurrency model. Let's revisit how Virtual Threads complete Platform Threads.

1. Payments to grow your world
TechSquad PPT Toolbox
Loom
promises
be there!

2. Get in touch:
@jefrajames
jean-francois.james@worldline.com
linkedin.com/ln/jefrajames
Jean-François JAMES
Software Architect
• Focus on Java, Jakarta EE, MicroProfile
• Open Source contributor
• Head of DevRel

3. Get in touch:
@foxlegend
david.pequegnot@worldline.com
linkedin.com/in/davidpequegnot/
David PEQUEGNOT
Performance Engineer
• Focus on JVM technologies
• ❤ Observability

4. We design payments technology
that powers the growth of millions
of businesses around the world.
Who are we?
7000+ engineers
in over 40 countries
Managing 28+ billion
transactions per year
€250M spent in R&D
every year
Handling 150+
payment methods

5. How your application server handles requests?
So, what’s the problem with our Java apps?
Application Server
Request 1
Request 2
Request n
Thread 1
Thread 2
Thread n
…
… Thread pool
Images: Flaticon.com/Freepik

6. Blocking, waiting, blocking, waiting, blocking, waiting …
So, what’s the problem with our Java apps?
Wait for WebService response Wait for database
Image: Flaticon.com/Freepik

7. May Reactive Be With You
Reactive vs Imperative
Request 1
Request 2
Request 3
Request 4
Request 5
…
Event
Loop
Image: Flaticon.com/Freepik
Imperative Reactive

8. Pro. & Cons.
Reactive vs Imperative
Request 1
Request 2
Request 3
Request 4
Request 5
…
Event
Loop
Image: Flaticon.com/Freepik

9. Code imperative, work reactive!
Block for free!
Loom promises

10. One project, 3 JEPs
Virtual
Threads
Lightweight threads
JEP 444
Stable with
Java 21 LTS
Structured
Concurrency
Facilitate tasks dev&
run on top of Virtual
Threads
JEP 453
Preview with
Java 21 LTS
Scoped
Values
Modernization,
optimization of
Thread Locals
JEP 446
Preview with
Java 21 LTS

11. Evolution of Java Concurrency
1997
Java 1.1
Green Threads
2004
Java 1.5
Executor
2014
Java 8
CompletableFuture
Parallel Streams
1998
Java 1.2
Native Threads
2011
Java 1.7
ForkJoinPool
2023
Java 21
Virtual Threads

12. From a few Platform Threads …
Platform Threads
OS Threads
OS Scheduling
Virtual Threads
OS
JVM
Kernel mode
User mode

13. … to millions Virtual Threads
Platform (Carrier) Threads
OS Threads
OS Scheduling
JVM Scheduling (ForkJoinPool)
Virtual Threads
OS
JVM

14. Inside the JVM: the magic of Continuation
Heap
Continuation.yield(scope) continuation.run()
Virtual Thread 1
Carrier Thread a
Carrier Thread b
Carrier Thread c
…
unmount
mount
ForkJoin
Pool
wait

15. Many changes in the JVM
No impact on user code (vs Kotlin’s coroutines)
Heap and GC activity to be further monitored and tuned
Not suitable for CPU-hungry processing
Loom promises
Keypoints

16. Payments to grow your world
TechSquad PPT Toolbox
Demo time!
Round 1
Java SE

17. • Basic Java SE tests
• Inspired from Eclipse Jetty loom-trial (Webtide)
• Code on GitHub
• Measured on MacOS (ARM M1, 8 CPU, 16 G RAM) with Java 20 (Temurin distro)
Methodology

18. Some code

19. Cheap to create?
0
50
100
150
200
250
1 2 4 8 16 32 32 64
vthread started/ms

20. Really cheap to create?
0
1
2
3
4
5
6
7
8
9
1 2 4 8 16 32 32 64
Carrier Threads
0
10,000
20,000
30,000
40,000
50,000
60,000
70,000
80,000
1 2 4 8 16 32 32 64
Heap size (MB)

21. • Up to 64 millions Virtual Threads in a single JVM!
• Just 8 Carrier Threads used in the background
• Same test with Platform Threads: 4K+ on MacOS and 30k+ on Linux
• About 200 Virtual Threads created/msec, 1 MB Heap/thread
• No hard limit with Virtual Threads: the limit is the Garbage Collector efficiency!
How long to start Virtual Threads?

22. One million Threads running a recursive genetic
mutation algorithm: is it possible?
TechSquad PPT Toolbox
DeepStack
Test conditions:
• Stack depth: 1000
• Timeout if Thread creation > 3s

23. Platform Threads
TechSquad PPT Toolbox
DeepStack

24. Virtual Threads
DeepStack

25. First results
How to increase the number of Virtual Threads? …
DeepStack
Platform Threads Virtual Threads
4k+ 30k+ 30k+
Images: Flaticon.com/Freepik

26. Threads over Heap Size
TechSquad PPT Toolbox
DeepStack
0
10000
20000
30000
40000
50000
60000
70000
1GB 2GB 4GB 8GB
Max
Threads
JVM Heap Size
Platform Virtual

27. Platform and Virtual Threads: Take aways
Platform Threads
Java’s traditional unit of concurrency
Trivial wrappers around OS Threads
Scarce resources
Expensive to create & block
Counter measures: thread pools, reactive
programming, cooperative scheduling
(async/await construct)
Virtual Threads
A new lightweight construct
Not an OS resource
Cheap to create & block
No counter measures needed
Price to pay: heap memory footprint

28. Risk of thread pinning
Continuation.yield(scope)
Virtual Thread 1
Carrier Thread a
Carrier Thread b
Carrier Thread c
…
unmount
ForkJoin
Pool
wait
{native code/JNI}
May reference addresses on the stack
(not supported by unmount/mount mechanism)
Images: Flaticon.com/Freepik

29. Avoid long synchronized blocks/methods
• Replace with ReentrantLock
• Check your dependencies
Make your code Loom-friendly
Thread pool not needed with VT
• Use Semaphore to limit the access of resources
Use Thread Locals with caution
• Virtual Threads support Thread Locals but amplify an existing issue
• Plenty of useless and Local Threads with critical data: transactional context, user id, permissions …
• Thread Locals should be removed!
• To be replaced with Scoped Variables in the mid-term: immutable, lifecycle limited to a task
DZone: Pitfalls to avoid when switching to virtual threads
0 200 400 600 800 1000 1200 1400 1600
PostgreSQL Driver 42.5.4 (non-loom friendly)
PostgreSQL Driver 42.6.0 (loom friendly)
Max. Requests Per Seconds (Virtual Threads)

30. Monitor
• Memory footprint
• GC activity
Observability & monitoring
-xlog:gc
Pinned Carrier Threads
Java options: -Djdk.tracePinnedThreads=short or -Djdk.tracePinnedThreads=full
Images: Flaticon.com/Freepik

32. Monitor
• Memory footprint
• GC activity
Observability & monitoring
-xlog:gc
Pinned Carrier Threads
Java options: -Djdk.tracePinnedThreads=short or -Djdk.tracePinnedThreads=full
Pinned thread occurrences
Thread[#50,ForkJoinPool-1-worker-1,5,CarrierThreads]
io.jefrajames.loomdemo.basic.LoomResource.pinnedRequest(LoomResource.java:76) <== monitors:1
Others
• Java Flight Recorder
• jstack / jcmd
Images: Flaticon.com/Freepik

33. Loom promises

34. Observability & monitoring
Virtual Threads Scheduling/ForkJoinPool
Java jdk.virtualThreadScheduler options:
• parallelism: number of Carrier Threads, default to CPU processors
• maxPoolSize: the parallelism may be temporarily expanded, at most 256
• minRunnable: number of Carrier Threads not blocked, half the pool size

35. Payments to grow your world
TechSquad PPT Toolbox
Back to demo!
Round Two
Helidon, Quarkus, Spring

36. • Inspired from Oracle Helidon demo
• Code on GitHub
• Comparing imperative programming with Virtual & Platform Threads, reactive programming
• Measuring throughput, memory footprint, quick vs slow request collision
• Same benchmark mixing REST API, dependency injection and JPA persistence
• REST/HTTP injector sending 10 threads * 6000 requests in //
• 10 worker threads configured on the server side
Methodology

37. Helidon 3
Reactive Web Server (Netty)
Plugable ExecutorService
Platform or Virtual Threads
Support reactive programming
Helidon 4
Aka NIMA
Opinionated approach
Natively based on Virtual Threads
Built in tight collaboration with the Java team
Web Server mixing Platform & Virtual Threads
Business Logic run on Virtual Threads
Open-Source from Oracle
Java libs for Cloud Native, Microservices
Focus on simplicity and performance
2 flavors: SE and MP
Native Image support

38. Helidon Performance
27,000
28,000
29,000
30,000
31,000
32,000
33,000
34,000
35,000
36,000
Helidon 3
Imperative code
Platform Threads
Helidon 3
Imperative code
Virtual Threads
Helidon 3
Reactive code
Nima
Imperative code
Virtual Threads
Throughput (req/sec)

39. Helidon Memory Footprint
0
50
100
150
200
250
Helidon 3
Imperative code
Platform Threads
Helidon 3
Imperative code
Virtual Threads
Helidon 3
Reactive code
Nima
Imperative code
Virtual Threads
Heap size
Max Heap (MB)

40. • Basic adoption of VirtualThreads with Helidon 3 Executors.newVirtualThreadPerTaskExecutor()
• Not optimal: more memory, less performance!
• Nima refactored to be nativelly based on Virtual Threads
• Nima Performance and memory footprint comparable to Reactive Programming
• With standard blocking Jakarta EE & MicroProfile code!
Helidon & Virtual Threads

41. Aka. the "pragmatic"
Open-Source from Red Hat
Java libs for Cloud Native, Microservices
« Supersonic Subatomic Java »
Native Image support
IO Threads
Aka Event Loop
Can’t block
Worker Threads
Can block
Platform
Threads
Default
Virtual
Threads
@RunOnDefaultThread

42. • Reactive programming with Mutiny delivers the best performance
• Quarkus not (yet) nativelly based on Virtual Threads, based on IO & Worker Threads
• Optionnaly, Worker threads can be Virtual
• Performance & memory footprint comparable with Platform & Virtual Threads
• So … Is it worth using Virtual Threads with Quarkus?
• Let’s see what happens, when calling concurrently quick and slow endpoints
Quarkus and Virtual Threads

43. Some benchmarks
PostgreSQL
300ms
25ms
System
Under
Test
JVM heap size: 4g
4 vCPU
16GB RAM
Constant load: 500VU
Images: Flaticon.com/Freepik

44. Code!
@Path("/uuid")
public class UUIDResource {
@Inject
UUIDRepository uuid;
@Inject@RestClient
ThirdPartySleepServiceClient client;
@GET
@Path("/platform")
@Produces(MediaType.APPLICATION_JSON)
public UUID uuidPlatform() {
client.timed(300);
return uuid.generateRandom(0.025);
}
}
@Path("/uuid")
public class UUIDResource {
@Inject
UUIDRepository uuid;
@Inject@RestClient
ThirdPartySleepServiceClient client;
@GET
@Path("/virtual")
@Produces(MediaType.APPLICATION_JSON)
@RunOnVirtualThread
public UUID uuidVirtual() {
client.timed(300);
return uuid.generateRandom(0.025);
}
}
Platform Threads Virtual Threads

45. Code!
Reactive Model
@Path("/uuid")
public class UUIDResource {
@Inject @RestClient
ThirdPartySleepServiceClient client;
@Inject
UUIDRepository repository;
@GET
@Produces(MediaType.APPLICATION_JSON)
public Uni<UUID> uuid() {
return client.timed(300).onItem().transformToUni(x -> repository.generateRandomUUID(0.025));
}
}

46. Requests Per Second and Average Response Time per Thread Model
141
283
564
843
1121
1390
1493
1388
1334
3520
1760
885
592
446 360 334 360 374
0
500
1000
1500
2000
2500
3000
3500
4000
0
200
400
600
800
1000
1200
1400
1600
ms
Requests
per
Second
Max RPS Average Response Time
Thread per Request

47. Process Max Memory Usage (Resident Set Size) per Thread Model
645
325
497
423
0
100
200
300
400
500
600
700
Thread per Request (500 PT) Reactive Virtual Virtual (native)
Memory
Usage
(MB)

48. Replace Tomcat's Executor
@SpringBootApplication
@EnableFeignClients
public class SpringBoot3WebApplication {
@Bean
AsyncTaskExecutor taskExecutor() {
ExecutorService executorService = Executors.newVirtualThreadPerTaskExecutor();
return new TaskExecutorAdapter(executorService::execute);
}
@Bean
TomcatProtocolHandlerCustomizer<?> protocolHandlerVirtualThreadsCustomizer() {
return protocolHandler ->
protocolHandler.setExecutor(Executors.newVirtualThreadPerTaskExecutor());
}
public static void main(String[] args) {
SpringApplication.run(SpringBoot3WebApplication.class, args);
}
}

49. Requests Per Second and Average Response Time per Thread Model
141
280
562
837
1109
1369 1390
1338
3500
1760
885
596
450 365 359 373
0
500
1000
1500
2000
2500
3000
3500
4000
0
200
400
600
800
1000
1200
1400
1600
50 PT 100 PT 200 PT 300 PT 400 PT 500 PT Reactive Virtual
Threads
ms
Requests
per
Second
Max RPS Average Response Time
Thread per Request

50. Process Max Memory Usage (Resident Set Size) per Thread Model
727
609
804
0
100
200
300
400
500
600
700
800
900
Thread per Request
(500)
Reactive Virtual
Memory
Usage
(MB)

51. 1. Understand the principles of Virtual Threads
2. Check how your favorite frameworks and libs have adopted them
3. Do some realistic benchmarks before going to production, monitor in production
4. Bench and monitor in JVM and in GraalVM/Mandrel Native Image mode
5. Things are improving fast: re-bench regularly!
6. Reminder: no benefit for CPU-hungry processing, …
Getting ready for Virtual Threads

52. Loom promises
The more you block,
The better!

53. Contact:
JF James & David Pequegnot
Worldline
Thanks for your
attention!
Open Feedback

54. Contact:
JF James & David Pequegnot
Worldline
Appendix

55. • Asbtract away the use of Virtual Threads
• Enable to coordinate tasks running on Virtual Threads in the context of a “scope”
• Built-in coordination strategy: any, all
• Extensible coordination strategy
• No back pressure
• Still incubator
TechSquad PPT Toolbox
Structured Concurrency

56. • Thread locals not designed to be shared by “millions” of threads
• Unclear lifecycle: not always cleaned up
• Uncontrolled mutability: can be changed at any time
• Inheritance: risk of high memory footprint
• Bound to a callable (not a Thread)
TechSquad PPT Toolbox
Scoped Values