Porto Tech Hub Conference 2023 - Revolutionize Java DB AppDev with Reactive Streams and Virtual Threads

Revolutionize Java Database Application
Development with Reactive Streams and
Virtual Threads
Porto Tech Hub Conference 2023
Juarez Barbosa Junior @juarezjunior
Sr. Principal Java Developer Evangelist
ORACLE
Copyright © 2023, Oracle and/or its affiliates

Juarez Álvares Barbosa Junior
Senior Principal Java Developer Evangelist
• Coming from Dublin, Ireland
• Developer since 1995 (Java ☕️ 1997)
• 28 years of experience in SW Engineering & DevRel
• Microsoft, Oracle, IBM, Nokia, Unisys, Accenture, startups
• Microsoft Azure Developer Relations Lead
• IBM Watson Tech Evangelist & Cloud Rockstar
• IBM Mobile Tech Evangelist & Global Thought Leader
• Nokia Developers Global Champion
• Java, Python, Cloud, DevOps, SRE, Cloud-native, IoT, AI,
Blockchain, Rust
• Speaker at conferences
• Oracle CloudWorld, Oracle Code, Microsoft Ignite, Microsoft
TechX, jPrime, JCON, DevConf.cz, GeeCon, DevOpsDays,
DeveloperWeek, DevOps Institute, CloudLand, DWX, The
Developer’s Conference (TDC), Sec4Dev, JSNation, NodeConf,
Conf42, Shift Conf, Global Azure, Open-Source Lisbon,
CodeFrenzy, Mêlée Numérique, React Summit, Test.js Summit,
Porto TechHub Conf, Pyjamas, JUGs, meetups, etc.
@juarezjunior
@juarezjunior

Agenda
• Java App Dev with Oracle Database
• Oracle JDBC - Support for the Latest Java Versions
• Overview of Oracle DB Access with Java
• Oracle JDBC – Sync and Async
• Classic Java Platform Threads
• Project Loom – Virtual Threads
• Virtual Threads - JEPs 425, 436, 444
• Demo # 1: Virtual vs Platform Threads
• Reactive JDBC - Synchronous vs Asynchronous JDBC
• Reactive Streams Ingestion (RSI)
• Demo # 2: Reactive Streams Ingestion (RSI)
• From Sync to Reactive JDBC: Oracle R2DBC
• Demo # 3: Oracle R2DBC with Project Reactor
• Live Labs/Free Oracle Cloud Account/Oracle ACE Program

Java App
Dev with
Oracle
Database

Oracle JDBC - Support for the Latest Java
Versions
• Java 11 - native support, compiled with it
• Java 17 - certified
• JDBC Standards - 4.2 and 4.3
• GraalVM - native image instrumentation
• Reactive Streams - Java Flow API support
• Project Loom - Virtual Threads support
• Data access is critical in mission-critical
apps

Overview of Oracle DB Access with Java

Oracle JDBC –
Async and Sync
• Project Loom - Virtual Threads
• Synchronous database access with lightweight threads
• Standard JDBC + Virtual Threads
• Client application call stack may use blocking, synchronous code
• Libraries must be compatible with Virtual Threads
• Oracle instrumented the Oracle JDBC driver to support Virtual Threads
• Reactive Programming
• Asynchronous database access with non-blocking network I/O
• Oracle Reactive Streams Ingestion + Oracle R2DBC + Oracle JDBC Reactive Extensions
(Flow)
• Libraries are available: Reactor, RxJava, Akka, Vert.x

Classic Java
Platform Threads
• Database access with blocking threads
• A JDBC call blocks a thread for 100s of milliseconds
(thread-per-request style)
• Thread count increases linearly with the number
of JDBC calls
• Performance degrades as the number of threads
increases
• 1 MB of stack memory per thread typically
• Scheduling many platform threads is expensive
• Preemptive scheduling vs time-slicing

Virtual Threads - JEPs 425, 436, 444
• Virtual Threads – JEPs (JDK Enhancement Proposals)
• Lightweight (user mode) threads that dramatically reduce the effort of writing,
maintaining, and observing high-throughput concurrent applications
• Enable applications written in the simple thread-per-request style to scale with near-
optimal hardware utilization
• Enable easy troubleshooting, debugging, and profiling of virtual threads with existing JDK
tools
• Do not remove the traditional implementation of threads
• Do not alter the basic concurrency model of Java
• Enable existing code that uses Java threads (java.lang.Thread) to adopt virtual threads with
minimal change

Virtual Threads - JEPs 425, 436, 444
• Virtual Threads – JEPs (JDK Enhancement Proposals)
• Virtual threads typically employ a small set of platform threads used as carrier threads
• Code executing in a virtual thread is not aware of the underlying carrier thread
• The currentThread() method will always return the Thread object for the virtual thread
• Virtual threads do not have a thread name by default. The getName() method returns the
empty string if a thread name is not set
• Virtual threads have a fixed thread priority that cannot be changed
• Virtual threads are daemon threads so do not prevent the shutdown sequence from
beginning (low-priority ones).

Virtual
Threads -
JEPs 425,
436, 444
• JDK Enhancement Proposals
• JEP 425: Virtual Threads (Preview)
• JEP 436: Virtual Threads (Second Preview)
• JEP 444: Virtual Threads
• java.lang.Thread
• final Boolean - isVirtual()
• static Thread.Builder.OfVirtual - ofVirtual()
• static Thread.Builder.OfPlatform - ofPlatform()
• static Thread - startVirtualThread(Runnable task)
• java.lang.Thread.Builder
• java.util.concurrent.Executors
• static ExecutorService -
newVirtualThreadPerTaskExecutor()

Virtual Threads -
JEPs 425, 436,
444
• java.lang.Thread.Builder
• Thread defines a
Thread.Builder API for
creating and starting
both platform and
virtual threads. The
following are
examples that use the
builder:

Demo # 1: Virtual vs
Platform Threads
• Virtual Threads vs Platform Threads
• JEP 425 Virtual Threads (Preview)
• JEP 436 (Second Preview)
• JEP 444 (JDK 21)
• Runs on Java 19, 20, 21
• javac --release 19 --enable-preview
• java --enable-preview
• Oracle JDBC Driver instrumented to support Virtual
Threads
• Verifiable comparison of OS/HW resources
consumption (Platform Threads x Virtual Threads)

Reactive JDBC - Sync vs Async JDBC
Setup
Blocking
Handle Result
Setup
Non-Blocking
Handle Result
Synchronous JDBC Setup
Blocking
Handle Result
Setup
Non-Blocking
Handle Result
Setup
Non-Blocking
Handle Result
Reactive JDBC
Database
Setup
Blocking
Handle Result
Database

Reactive Streams Ingestion (RSI)
• Java Library for Reactive Streams Ingestion
• Streaming capability: Ingest data in an unblocking, and
• reactive way from a large group of clients
• Group records through RAC (Real App Clusters),
• and Shard affinity using native UCP (Universal Connection
• Pool)
• Optimize CPU allocation while decoupling record
• Processing from I/O
• Fastest insert method for the Oracle Database through
• Direct Path Insert, bypassing SQL and writing directly into the DB files

Demo #2: RSI - Architecture

Demo #2:
RSI - Project
Structure

Demo # 2: Reactive Streams Ingestion (RSI)
Container
Pipelines,
Jenkins, etc.
Build
Test
Push
Push Docker
images to
Registry
Cloud
Infrastructur
e Registry
Container
Engine for
Kubernetes
Pull images
from Registry
Deploy
images to
production
Kubernetes
worker nodes
Containers
running
microservices
deployed over
Kubernetes
ORACLE CLOUD INFRASTRUCTURE
ATP, ADW, ATP-D,
AFDW-D
Memoptimized
Rowstore
RSI Runtime: Non-
blocking, optimized library
for streaming data
through Direct Path, Shard
& RAC/FAN support.
HTTP / REST Engine over
Helidon
Define build
for CI/CD
toolchain
gRPC / AMQP / MQTT
Engines
Microservices
Files / Logs
IoT
Devices
/
Apps
cv
MQTT
gRPC
AMQP
HTTP / REST
JDBC
Direct Path
INSERT
Record
Streaming
over
multiple
protocols.

From Sync to Reactive JDBC: Oracle
R2DBC
• Oracle Reactive Relational Database Connectivity (R2DBC)
• Oracle R2DBC Driver is a Java library that supports reactive
programming with the Oracle Database
• It implements the R2DBC Service Provider Interface (SPI) as
specified by the Reactive Relational Database Connectivity
(R2DBC) spec
• The R2DBC SPI exposes Reactive Streams as an abstraction
for remote database operations
• The sample code uses Project Reactor. It could use RxJava,
Akka, or any Reactive Streams library
• Runs on Java 11+
• Oracle RDBC 1.1.1 (2023), Apache v2.0, OSS
R2DBC – Reactive Relational DB Connectivity

Demo # 3: Oracle R2DBC
static String queryJdbc(java.sql.Connection connection) throws
SQLException {
try (java.sql.Statement statement = connection.createStatement()) {
ResultSet resultSet =
statement.executeQuery("SELECT * FROM CUSTOMERS");
if (resultSet.next())
return resultSet.getString(1);
else
throw new NoSuchElementException("Query returned zero rows");
}
}
static Publisher<String> queryR2dbc(io.r2dbc.spi.Connection
connection) {
return Flux.from(connection.createStatement(
"SELECT * FROM CUSTOMERS")
.execute())
.flatMap(result ->
result.map(row -> row.get(0, String.class)))
.switchIfEmpty(Flux.error(
new NoSuchElementException("Query returned zero rows")));
}

Virtual Threads or
Reactive?
• Oracle JDBC supports both!
• Want Virtual Threads?
• The Oracle JDBC driver has been
“Virtual Thread Compatible” since 21c
• Want Reactive?
• Oracle R2DBC 1.1.1 is available now
• Consume Flow interfaces directly
from Oracle JDBC’s Reactive
Extensions

Virtual Threads or Reactive?
• Benefits of Virtual Threads:
• Easier to read and write
• Easier to debug
• Integration with JDK tools
• Do not alter the basic concurrency model of Java
• Now available in JDK 21
• Limitations of Virtual Threads:
• Some libraries/frameworks are not
compatible yet
Benefits of Reactive:
• Reactive Libraries (Reactor, RxJava, Akka, Vert.x)
• Stream-like API with a functional style
• Low-level concurrency is handled for you
(locks, atomics, queues)
Limitations of Reactive:
• Steep learning curve
• Harder to read and write
• Harder to debug

References
• JDK 21
• The Arrival of JDK 21 - https://blogs.oracle.com/java/post/the-arrival-of-java-21
• Project Loom / Virtual Threads
• Loom - https://openjdk.org/projects/loom/
• JEP 444 Virtual Threads (Targeted) - https://openjdk.org/jeps/444
• Introduction to Oracle JDBC 21c Driver Support for Virtual Threads - https://bit.ly/3UlNJWP
• Reactive Streams Ingestion Library
• Getting Started with the Java library for Reactive Streams Ingestion (RSI) -
https://bit.ly/3rEiRnC
• High-throughput stream processing with the Java Library for Reactive Streams Ingestion (RSI),
Virtual Threads, and the Oracle ATP Database - https://bit.ly/3rATCTd
• RSI - https://docs.oracle.com/en/database/oracle/
• R2DBC
• Oracle R2DBC Driver – https://github.com/oracle/oracle-r2dbc
• Develop Java applications with Oracle Database
• JDBC – https://www.oracle.com/database/technologies/appdev/jdbc.html

Oracle
Database
23c Oracle Database 23c Free – Developer Edition
available for download now
• Oracle Database 23c accelerates Oracle’s
mission to make it simple to develop and
run all data-driven apps
• Provides developers easy early access to
23c app dev features
• Limited database size, memory, CPU
threads (same limits as Express Edition)
Free Developer Release
http://oracle.com/23cFree
http://oracle.com/23cFree

Oracle LiveLabs
Showcasing how Oracle’s solutions can
solve your business problems
500+
free workshops,
available or in
development
3.5 million
people have already visited
LiveLabs
developer.oracle.com/livelabs
learn something new …at your pace!
600+
events run
using LiveLabs
workshops

3 membership tiers
Connect: @oracleace facebook.com/OracleACEs
aceprogram_ww@oracle.com
500+ technical experts &
community leaders helping peers globally
The Oracle ACE Program recognizes & rewards individuals for
their technical & community contributions to the Oracle community
Nominate
yourself or a candidate:
ace.oracle.com/nominate
Learn more - ace.oracle.com
blogs.oracle.com/ace

Create your FREE
Cloud Account
• Go to
https://signup.cloud.oracle.com/

Porto Tech Hub Conference 2023 - Revolutionize Java DB AppDev with Reactive Streams and Virtual Threads

Porto Tech Hub Conference 2023 - Revolutionize Java DB AppDev with Reactive Streams and Virtual Threads

More Related Content

Similar to Porto Tech Hub Conference 2023 - Revolutionize Java DB AppDev with Reactive Streams and Virtual Threads (20)

More from Juarez Junior (20)

Recently uploaded (20)

Porto Tech Hub Conference 2023 - Revolutionize Java DB AppDev with Reactive Streams and Virtual Threads