Java 23

Mehr Handlung, mehr Übersicht

Merlin Bögershausen

MBoegie@fosstodon.org

@mboegie

betterCode()

@bettercodeconf

Java Software Engineer

Line of Business Public

Oracle ACE Associate

betterCode() / @bettercodeconf

Merlin Bögershausen / @mboegie

♻️ Recap on Threads ♻️

Threads in general

Threads in general are used to group Activities in a certen order. I thread is froked from its parent and at some point is joined again. Between fork and join a thread executes operations in a defined order.

If multiple threads are run in paralell concurrency problems like syncronization and concurrent access enter the game.

If a thread is managed by the OS, outside of the JVM, it refered to as a platform thread.

Threads in general have a state model that look different from every OS but it can be condensed to the JVM states on the right. They start as new, here they canot run yet. After moving to Runable thes are considered for scheduling. Blocked and Waiting are two simlar states that are of interest if we consider Scheduling. If terminated a thread is ready for disposal and will not receive any computation time.

Threads in Java

class ExampleThread extends Thread {
  public void run() { /* Do it */}
}
var t1 = new ExampleThread();

class ExampleRunable implements Runable {
  public void run() { /* Do it again */}
}
var runable = new ExampleRunable();
var t2 = new Thread(runable);

t2.start(); t1.start();
t2.join(); t1.join();

Concurrency Models ^[1]

ExecutorService

Thread Pool Management
reuse OS Threads

CompletableFuture

Composing asyncron operations
handling Results

1. Credits to Hanno Embregts on Devoxx.BE 2024, slides

JEP 444 Virtual Threads

Virtual threads are lightweight threads that improve Maintanace and Obervability.

Platform vs. Virtual

Creation of Virtual

Thread.ofVirtual().start(() -> doIOStuffInParallel());

Thread.ofPlatform() // is new as well

Better use Executors

Executors.newVirtualThreadPerTaskExecutor()
	.submit(() -> doIOStuffInParallel());

Awesome, now what?

Lightweight?
Maintainabllility?
Oberservability?

Example we Work with

Today I want to use a RuleEngine as example to work with. A lot of poeple dislike RuleEniges for various reasons but they can be simple.

CLICK

A RuleEngine is nothing more than a List of Rules that are executed when input data is provided. Our Rules here define to methods to read adress and Names from somewhere and have a fire Method to implement where the data rule is executed. At first we stay at this level and later one we see the code in small bites.

One thing to notice is that the Engine holds an SSLContext that is intended to be used in execution. It can be used for Requests by the rules, this is an often see situation in Frameworks. The users code (RuleImplementation) needs something from the Framework to do the job, often in thread-safe and concurrent ways.

Here is missing that we want cocurrency and thread safty.

JEP 481 Scoped Values

Share immutable data between callees within a thread and child threads.

Concept

Goals of Scoped Values

🥅 Ease of use
🥅 Comprehensibility
🥅 Robustness
🥅 Performance

ScopesValues API

final static ScopedValue<SSLContext> VAL
                    = ScopedValue.newInstance();

ScopedValue.where(VAL, value)
           .run(() -> VAL.get());

ScopedValue.runWhere(VAL, value, () -> /* ... */);

Framework - Creation

private final static ScopedValue<Map<String, String>>
    INPUTDATA = ScopedValue.newInstance();

private final static ScopedValue<SSLContext>
    SSL_CTX = ScopedValue.newInstance();

Framework -Config

ScopedValue.Carrier executionScope = ScopedValue
    .where(INPUTDATA, Map.copyOf(data))
    .where(SSL_CTX, SSLContext.getDefault());

Framework - Execution

// ScopedValue.Carrier executionScope;

for (var r : rules) {
    executionScope.run(r::fire);
}

Usercode - Access I

//ScopedValue<Map<String, String>> INPUTDATA;

String inputName = INPUTDATA
        .orElseThrow(new IllegalArgumentException())
        .getOrDefault("name", "JON");

Usercode - Access II

// ScopedValue<SSLContext> SSL_CTX

if(SSL_CTX.isBound()) {
    intputName = "%s %s".formatted(
            inputName, getLastName(SSL_CTX.get()));
}

Comparison ^[1]

ScopedValues

Immutable Carrier
Same instance
Rebindable

ThreadLocal

Supplier
Instance per Thread
Mutable Value

1. full length comparison by Alex Klimenko on Medium

JEP 480 Stuctured Concurrency

Treat groups of related tasks running in different threads as a single unit of work, thereby streamlining error handling and cancellation, improving reliability, and enhancing observability.

Concept

Task Scope API

public class StructuredTaskScope<T> implements AutoCloseable {
  public <U extends T> Subtask<U>
        fork(Callable<? extends U> task);

  public StructuredTaskScope<T> join()
        throws InterruptedException;
  public StructuredTaskScope<T> joinUntil(Instant deadline)
        throws InterruptedException, TimeoutException;

  public void shutdown();
  public void close();
}

The general workflow of code using StructuredTaskScope is:

Create a scope. The thread that creates the scope is its owner.
Use the fork(Callable) method to fork subtasks in the scope.
At any time, any of the subtasks, or the scope’s owner, may call the scope’s shutdown() method to cancel unfinished subtasks and prevent the forking of new subtasks.
The scope’s owner joins the scope, i.e., all of its subtasks, as a unit. The owner can call the scope’s join() method, to wait until all subtasks have either completed (successfully or not) or been cancelled via shutdown(). Alternatively, it can call the scope’s joinUntil(java.time.Instant) method, to wait up to a deadline.
After joining, handle any errors in the subtasks and process their results.
Close the scope, usually implicitly via try-with-resources. This shuts down the scope, if it is not already shut down, and waits for any subtasks that have been cancelled but not yet completed to complete.

Shutdown Policies

ShutdownOnFailure first task failed

ShutdownOnSuccess first task successfully terminates

Structured Concurrency in Rule

try (var scope = new StructuredTaskScope.ShutdownOnFailure()){
    Supplier<String> adr = scope.fork(() -> readAddress());

    scope.join().throwIfFailed();

    var addres = adr.get();
} catch (ExecutionException | InterruptedException e) {
    throw new RuntimeException(e);
}

Final words

Never pool VirtualThreads
Migrate immediately
ThreadLocal never mutated ⇒ ScopedValues
IO Concurrency ⇒ StructuredConcurrency

GitHub GIST with full code

Contact

Me

MBoegie@fosstodon.org // @MBoegi // MBoegers

adesso

Infos // DevBlog

Approach direct

I'm here all day with cookies!

Jobs

Image Credits

Knited Speach Blubled generetd with deepai.org
Virtual reality background generetd with deepai.org
Elderly Person handing over treats generated with deepai.org
Chaos of pipes and notations generated with deepai.org

Java 23

Mehr Handlung, mehr Übersicht

♻️ Recap on Threads ♻️

Threads in general

Threads in Java

Concurrency Models [1]

JEP 444 Virtual Threads

Platform vs. Virtual

Creation of Virtual

Better use Executors

Awesome, now what?

Example we Work with

JEP 481 Scoped Values

Concept

Goals of Scoped Values

ScopesValues API

Framework - Creation

Framework -Config

Framework - Execution

Usercode - Access I

Usercode - Access II

Comparison [1]

JEP 480 Stuctured Concurrency

Concept

Task Scope API

Shutdown Policies

Structured Concurrency in Rule

Final words

Contact

Me

adesso

Approach direct

Jobs

Image Credits

Concurrency Models ^[1]

Comparison ^[1]