To run each example use: java --enable-preview --source 20 <FileName.java>

• 429 - Scoped Values (Incubator)
• 432 - Record Patterns (Second Preview)
• 433 - Pattern Matching for switch (Fourth Preview)
• 434 - Foreign Function & Memory API (Second Preview)
• 436 - Virtual Threads (Second Preview)
• 437 - Structured Concurrency (Second Incubator)
• 438 - Vector API (Fifth Incubator)

• Record Patterns (second preview)
  • added support for inference of type arguments of generic record patterns;
    • now it generic type can be inferred
    • given record Decorator<T>(T t) {} and variable Decorator<Decorator<String>> wr, the record pattern generic type can be inferred in w insteaceof Decorator(Decorator(var s))
  • added support for record patterns to appear in the headere of an enhanced for statement;
    • for (Point(var x, var y) : shapePoints)
  • remove support for named record pattner.
• Patteren Matching for switch (fourth preview)
  • added support for inference of type arguments for generic record patterns
• Virtual Threads (second preview)
  • small numbeer of API changes described by JEP 425 were made permanent in JDK 19 and are not proporsed to preview:
    • Thread.join(Durantion)
    • Thread.sleep(Duration)
    • Thread.threadId()
    • Future.resultNow()
    • Future.exceptionNow()
    • Future.state()
    • ExecutorService extends AutoClosable
• Scoped Values (incubator)
  • enable the sharing of immutable data within and across threads
  • it were inspired by the way that Lipst dialects provide support for dyanamically scoped free variables
  • they are preferred to thread-local variables (specially using virtual threads)
  • goals:
    • provide a programming model to share data both within a thread and with child threads
    • make the lifetime of shared data visible from structure of code
    • ensura that data sahred by a caller can be retrieved only by legitimate callees
    • thread shared data as immuatable so as to allow sharing by a large number of threads and to enable runtime otimiziations
  • problems with thread-local variables:
    • mutability: any object can update the variable if it has access to it
    • unbounded lifetime: it is stored until the thread is destroyed, if is used in a pool it can take a long time
    • expensive inheritance: a child thread must allocate memory for every variable stored in the parent thread
  • a scoped value allows data to be safely and efficiently shared between components
  • we use an attribute of type ScopedValue declared as final static
    • scoped value has multiple incarnations, one per thread
    • once the value is written to scoped value it becomes immutable and is available only for a bounded period during execution of a thread
  • we can create nested scope when inside a scope we use another variable to create a scope
  • we can create nested scope with rebinded value when using the same ScopedValue to create a new scope
    • the created scope will have the new value binded
    • the current scope will still have its original value
  • usage:
    • we use ScopedValue.where to set the value
    • then use the method run or call to bind the scoped value with the current thread and defining the lambda expression
    • the scope of the methods run/call, the lambda expression (and every method called by it) can access the scoped value using the method get from static final attribute
  • ex.: *

    public final static ScopedValue<String> PRINCIPAL = ScopedValue.newInstance();
    // [...]
    ScopedValue.where(PRINCIPAL, "guest")
    	.run(() -> {
    		var userRole = PRINCIPAL.get();
    	});
  • ScopedValue.where provides a one-way sharing to the execution scope of method run
  • to receive a result from another execution scope we need to use call instead of run
  • ex.: *

    var universeAnswer = ScopedValue.where(SUBJECT, "Deep Thought")
    	.call(() -> {
    		// some magic
    		return 42;
    	});
  • virtual thread and cross-thread sharing
    • to share data between a thread and its child thread we need to make the scoped values inherited by child thread
      • we can use the Structured Concurrency API
      • the class StructuredTaskScope automatically make the scoped value inherited by child thread
      • the fork must occurrs inside the ScopedValue method run/call
      • the binding will remains until the child thread are finished and we can use StructuredTaskScoped.join to ensure that the child threads will terminate before run/call
    • when we try to access a scoped value not shared with current thread an exception NoSuchElementException will be thrown
• Structured Concurrency (second incubator)
  • no changes in API since JDK 19
  • added support to inheritance of scoped values

• default timeout in HttpClient changed to 30 seconds.
• fixed IdentityHashMap methods remove and replace to be conformed with its specification (using object identity, ==).

Removed:

• Thread methods suspend, resume and stop changed to throw UnsupportedOperationException.

• JDK 20 Jeps
• Consolidated JDK 20 Release Notes
• JEP Dashboard
• JDK 20 EA Builds
• Java Scoped Values: Better ThreadLocals