Java 19 introduces several new features and improvements to help applications scale better. These include virtual threads which allow efficient asynchronous programming without blocking threads, pattern matching for more readable code, and improvements to JNI for safer native code integration. Java 19 also deprecates some legacy methods and makes timezone data updates to improve sustainability. Overall, the release focuses on enhancing scalability and maintainability for high performance applications.

1. How Java 19 Influences The
Future Of Your High-Scale
Applications

2. Java Champion Alumni, Certified Architect
Senior Developer Advocate
Passionate about solving complex scenarios involving Java and
Kubernetes.
@ammbra1508.mastodon.social

3. Any Change Starts with
Why

4. Why is Scalability Important?
Can cause service
disruptions that drive end users
away.
Impacts a business’s ability to
meet demands that
continuously change.
Reduces IT costs when demand
is less, and the system(s)
should downscale.

5. Types of Scalability
Vertical Scaling
Increase
RAM/CPU
Increase the number of machines
Horizontal Scaling

7. How Application Scalability
Matters

8. Application Scalability
An application's ability to handle a
growing number of users and load.
Not compromising on performance
or causing disruptions to user
experience when demand increases.
Measured by the number of requests
it can effectively support
simultaneously.

9. Scaling Through Elastic Adjustments
A combination of improvements to
network bandwidth, CPU and
memory requirements, and hard
disk adjustments.
Application needs to be correctly
configured, align the right software
protocols and hardware to meet
increasing number of requests per
seconds.

10. Write Once, Run Anywhere

11. A Partial History Of Running Anywhere
During the 1970s, computer science
focused on increasing the complexity of
computer architectures.
Semiconductor technology favoured a
type of computer architecture capable to
of complex instruction set computers
(CISCs).

12. From CISC to RISC
C. David Patterson and Carlo Sequin from
the University of California at Berkeley
thought that by simplifying the processor
a better performance can be achieved at a
much lower cost.
This hypothesis translated into RISC,
reduced instruction set computer.

13. Key Features of RISC-V
Simple
instruction set
Modularity Extensibility Open
Standard
Load-store
architecture
*At the moment, RISC-V still has limited hardware support.

14. The port will support the HotSpot subsystems
The template
interpreter
The C1 (client)
JIT compiler
The C2 (server)
JIT compiler
All current
mainline GCs,
including ZGC
and Shenandoah.
JEP 422 focuses on integration of the
Linux/RISC-V port into the JDK main-line
repository.

15. From ISA To SIMD
RISC-V is a free and open-
source RISC instruction set
architecture (ISA)
CPU architectures include
extensions to their instructions
sets that allow applying a
single instruction to multiple
data items simultaneously
(SIMD).
Heterogeneous ISAs offer
clock speed/parallelism
tradeoffs for workloads with
frequent usage of SIMD
instructions.

17. Portable Java ~ Efficient Java

18. Coding Style of Choice
Synchronous Asynchronous

19. Continuations
Scheduler
Thread

20. Platform Threads and Scaling
Platform threads take up
considerable memory to exist.
When you have lots of
blocking I/O, threads are just
waiting for data, and the CPU
is not utilized to its full
capacity.
Context switch for platform
threads is costly in terms of
resources.

21. Reactive Programming To The Rescue?!
Offers non-blocking I/O by letting a running thread
make a blocking call.
Analysing the performance and costs of reactive programming libraries in Java focuses on
RxJava, Project Reactor, SmallRye Mutiny.

22. Reactive Programming To The Rescue?!
Offers non-blocking I/O by letting a
running thread make a blocking call.
Executes the rest of the program without
waiting for data from storage or the
network.

23. Reactive Programming To The Rescue?!
Offers non-blocking
I/O by letting a
running thread make a
blocking call.
Executes the rest of
the program without
waiting for data from
storage or the
network.
It keeps an event loop that
continuously checks whether the
socket received data.

24. Reactive Programming To The Rescue?!
Offers non-
blocking I/O by
letting a running
thread make a
blocking call.
Executes the rest of
the program
without waiting for
data from storage
or the network.
It keeps an event loop that
continuously checks whether the
socket received data.
Once data is received it will be
processed by another thread, so the
running thread does not get blocked.

25. Virtual Threads To The Rescue
A thread managed
by JVM scheduler
can get a task
assigned by you.
Java scheduler
assigns the virtual
thread to platform
thread(s).
Virtual thread asks platform
thread(s) to perform the task.
If a virtual thread has some blocking
I/O operation, it will be detached from
the platform thread.
Another virtual thread is assigned to the
platform thread so that the platform thread
stays in a running state
JEP 425 Virtual Threads (Preview)

26. Readable Code with Virtual Threads
Create one new virtual thread per task
Explicitly start a virtual thread

27. Maintainable Code with Virtual Threads
Explicitly start a virtual thread
Execute 1000 tasks

28. Maintainable Code with Virtual Threads
Create one new virtual thread per task

29. Unblocking Virtual Threads
sun.nio.ch.Poller thread
creates a map between the blocked
virtual thread and its corresponding
socket where data will be received.
Poller thread is a continuous
event loop that checks whether
the socket mapped to a
particular thread received data
or not.
java.internal.vm.Continuation
is a public low-level API that is used
in virtual threads, it can yield and
continue whenever required.

30. Herding Virtual Threads
JEP 428 Structured Concurrency (Incubator)

31. Herding Virtual Threads
JEP 428 Structured Concurrency (Incubator)

32. Herding Virtual Threads
JEP 428 Structured Concurrency (Incubator)

33. Benefits for High Scaling Applications
Higher throughput when having high
number concurrent requests, with fewer
CPU operations and threads spending
significant time waiting.
When having blocking calls, you can
scale well because virtual threads will go
in a waiting state until they receive data
while platform threads will continuously
use the CPU.

34. Cloud Native Java software is highly
distributed, evolves with the language, tools
and frameworks, and operates in a constantly
changing environment.

35. Faster, Safer, Easier Java-to-
Native Integration

36. JNI

37. From Unsafe To Proper Handling
Create an object without
running its constructor
Directly access hardware
features or the CPU
Manually manage off-heap
memory

38. Foreign Function & Memory API
Get lookup object for string library
Get method handler for strlen
Convert string to store it in
the off-heap memory
Invoke foreign function

39. JExtract From Native C Headers
export C_INCLUDE_PATH=/Library/Developer/CommandLineTools/SDKs
jextract --source --output src -t org.unix -I $C_INCLUDE_PATH $C_INCLUDE_PATH/string.h
java --enable-preview --enable-native-access=ALL-UNNAMED --source FFMBenchmark.java

40. Sustainable Design Impacts
Scalability

41. (Nested) Record Patterns
Java 16 style for Record Pattern
Java 19 style for Record Pattern

42. Pattern Matching For Switch
Java 17 (first preview) style
Java 19 (Third Preview) style

43. newHashMap()to Create Preallocated
HashMaps

44. Deprecation Of Locale Class Constructors
Before Java 19
After Java 19

45. Decommissioned Methods In ThreadGroup
• ThreadGroup.destroy()- invocations of this method will be ignored.
• ThreadGroup.getDaemon() – returns the value of the unused daemon flags
• ThreadGroup.isDestroyed() – always returns false.
• ThreadGroup.setDaemon() – sets the daemon flag without any effect.
• ThreadGroup.resume(), ThreadGroup.suspend(), ThreadGroup.stop throw
an UnsupportedOperationException.

46. It’s That Time(zone) Of The Year
• Chile's DST is delayed by a week in September 2022.
• Iran no longer observes DST after 2022.
• Rename Europe/Kiev to Europe/Kyiv.
• Finish moving duplicate-since-1970 zones to ‘backzone’.
source:

47. Thank YOU!

48. Additional Resources
• Java19 All Release Notes: https://www.oracle.com/java/technologies/javase/19all-relnotes.html
• Helidon Nima with Loom https://medium.com/helidon/helidon-n%C3%ADma-helidon-on-virtual-
threads-130bb2ea2088
• Quarkus guide with Virtual Threads: https://quarkus.io/guides/virtual-threads
• SpringBoot & Virtual Threads: https://spring.io/blog/2022/10/11/embracing-virtual-threads
• Loom Lab: https://github.com/nipafx/loom-lab
• Vector Math made easy: https://blogs.oracle.com/javamagazine/post/java-vector-api-simd
• FizzBuzz SIMD Style: https://www.morling.dev/blog/fizzbuzz-simd-style/
• JEP425 https://openjdk.org/jeps/425#java-lang-ThreadGroup
• https://bugs.openjdk.org/browse/JDK-8294042
• https://bugs.openjdk.org/browse/JDK-8292654