Java 20

import java.net.*;
import java.io.*;
import java.util.concurrent.*;

void startServer() throws IOException {
    try (var executor = Executors.newVirtualThreadPerTaskExecutor();
         var serverSocket = new ServerSocket(8080)) {

        while (true) {
            Socket socket = serverSocket.accept();
            executor.submit(() -> handleClient(socket));
        }
    }
}

void handleClient(Socket socket) {
    try (socket;
         var in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
         var out = new PrintWriter(socket.getOutputStream())) {

        String request = in.readLine();
        // Blocking I/O is fine - virtual thread will park
        String response = processRequest(request);
        out.println(response);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

record Point(int x, int y) {}
record Circle(Point center, double radius) {}
record Rectangle(Point topLeft, Point bottomRight) {}

sealed interface Shape permits Circle, Rectangle {}

// Nested pattern matching
static void processShape(Shape shape) {
    switch (shape) {
        case Circle(Point(int x, int y), double r) ->
            System.out.printf("Circle at (%d,%d) radius %.2f%n", x, y, r);
        case Rectangle(Point(int x1, int y1), Point(int x2, int y2)) ->
            System.out.printf("Rectangle from (%d,%d) to (%d,%d)%n", x1, y1, x2, y2);
    }
}

record Box<T>(T value) {}

static <T> void printBox(Box<T> box) {
    if (box instanceof Box(String s)) {
        System.out.println("String box: " + s);
    } else if (box instanceof Box(Integer i)) {
        System.out.println("Integer box: " + i);
    }
}

static String classify(Object obj) {
    return switch (obj) {
        case String s when s.length() < 5 -> "short string";
        case String s when s.length() >= 5 -> "long string";
        case Integer i when i > 0 -> "positive integer";
        case Integer i when i < 0 -> "negative integer";
        case Integer i -> "zero";
        default -> "unknown";
    };
}

static String describe(Object obj) {
    return switch (obj) {
        case null -> "null value";
        case String s -> "string: " + s;
        case Integer i -> "integer: " + i;
        default -> obj.toString();
    };
}

// ThreadLocal - mutable, error-prone
private static final ThreadLocal<User> CURRENT_USER = new ThreadLocal<>();

void processRequest(User user) {
    CURRENT_USER.set(user);
    try {
        doWork();
    } finally {
        CURRENT_USER.remove(); // Easy to forget!
    }
}

void doWork() {
    User user = CURRENT_USER.get();
    // Use user
}

import jdk.incubator.concurrent.ScopedValue;

// ScopedValue - immutable, safer
private static final ScopedValue<User> CURRENT_USER = ScopedValue.newInstance();

void processRequest(User user) {
    ScopedValue.where(CURRENT_USER, user)
               .run(() -> doWork());
    // CURRENT_USER automatically cleared after run()
}

void doWork() {
    User user = CURRENT_USER.get();
    // Use user
}

void handleRequest() {
    ScopedValue.where(REQUEST_ID, generateId())
               .where(USER, authenticateUser())
               .run(() -> {
                   String requestId = REQUEST_ID.get();
                   User user = USER.get();
                   processRequest();
               });
}

import jdk.incubator.concurrent.StructuredTaskScope;

// Return first successful result, cancel others
String fetchFromMultipleSources() throws Exception {
    try (var scope = new StructuredTaskScope.ShutdownOnSuccess<String>()) {
        scope.fork(() -> fetchFromSource1());
        scope.fork(() -> fetchFromSource2());
        scope.fork(() -> fetchFromSource3());

        scope.join();
        return scope.result(); // First successful result
    } // Other tasks automatically cancelled
}

class MyScope<T> extends StructuredTaskScope<T> {
    @Override
    protected void handleComplete(Future<T> future) {
        // Custom completion logic
        if (future.state() == Future.State.SUCCESS) {
            // Handle success
        } else if (future.state() == Future.State.FAILED) {
            // Handle failure
        }
    }
}

import java.lang.foreign.*;

// Load native library
Linker linker = Linker.nativeLinker();
SymbolLookup lib = SymbolLookup.libraryLookup("mylib", Arena.global());

// Call native function
MethodHandle hello = linker.downcallHandle(
    lib.find("say_hello").orElseThrow(),
    FunctionDescriptor.ofVoid(ValueLayout.ADDRESS)
);

try (Arena arena = Arena.openConfined()) {
    MemorySegment message = arena.allocateUtf8String("Hello from Java!");
    hello.invoke(message);
}

// Define C struct layout in Java
StructLayout pointLayout = MemoryLayout.structLayout(
    ValueLayout.JAVA_INT.withName("x"),
    ValueLayout.JAVA_INT.withName("y")
);

// Allocate and access struct
try (Arena arena = Arena.openConfined()) {
    MemorySegment point = arena.allocate(pointLayout);
    point.set(ValueLayout.JAVA_INT, 0, 10);  // x = 10
    point.set(ValueLayout.JAVA_INT, 4, 20);  // y = 20
}

import jdk.incubator.vector.*;

void brighten(byte[] pixels, byte[] output, float factor) {
    var species = ByteVector.SPECIES_PREFERRED;
    int i = 0;

    for (; i < species.loopBound(pixels.length); i += species.length()) {
        var v = ByteVector.fromArray(species, pixels, i);
        var brightened = v.convertShape(VectorOperators.B2F, FloatVector.SPECIES_256, 0)
                          .mul(factor)
                          .convertShape(VectorOperators.F2B, species, 0);
        brightened.intoArray(output, i);
    }

    // Handle remainder
    for (; i < pixels.length; i++) {
        output[i] = (byte) Math.min(255, pixels[i] * factor);
    }
}

java --enable-preview --add-modules jdk.incubator.concurrent --source 20 MyApp.java