Code-Bibliothek — Capypad · Code Zeile für Zeile lesen

Java · ExperteSnippet

Strukturierte Nebenläufigkeit mit StructuredTaskScope

Structured Task Scope (Preview in Java 21+) behandelt Gruppen zusammengehöriger Aufgaben, die in verschiedenen Threads laufen, als eine einzige Arbeitseinheit. ShutdownOnFailure stellt sicher, dass beim Fehlschlagen eines Subtasks alle anderen verwandten virtuellen Threads automatisch abgebrochen werden, was 'verwaiste' Threads verhindert und die Observability verbessert.

snippet.java

java

1

2

3

4

5

6

7

8

try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    Supplier<String> user = scope.fork(() -> fetchUser(id));
    Supplier<Integer> order = scope.fork(() -> fetchOrder(id));
 
    scope.join().throwIfFailed();
 
    return new Dashboard(user.get(), order.get());
}

Async & ConcurrencyBest Practices

Java · ExperteSnippet

Optimistisches Sperren mit StampedLock

StampedLock bietet einen 'optimistischen' Modus, bei dem keine echte Sperre gesetzt wird. Stattdessen wird ein 'Stamp' zurückgegeben, der später validiert werden muss. Falls während des Lesens ein Schreibvorgang stattfand, schlägt die Validierung fehl und es wird auf ein klassisches Read-Lock gewechselt.

snippet.java

java

1

2

3

4

5

6

7

8

9

10

11

long stamp = lock.tryOptimisticRead();
int currentX = x, currentY = y;
if (!lock.validate(stamp)) {
    stamp = lock.readLock();
    try {
        currentX = x; currentY = y;
    } finally {
        lock.unlockRead(stamp);
    }
}
return Math.sqrt(currentX * currentX + currentY * currentY);

PerformanceAsync & Concurrency

Java · ExperteSnippet

Dynamische Invokation mit MethodHandles

MethodHandles sind der Kernmechanismus hinter 'invokedynamic'. Sie bieten eine performantere und typsicherere Alternative zur klassischen Reflection. Sobald ein MethodHandle verknüpft ist, kann die JVM den Aufruf ähnlich wie eine direkte Methodeninvoaktion optimieren.

snippet.java

java

1

2

3

MethodType mt = MethodType.methodType(String.class, char.class, char.class);
MethodHandle mh = MethodHandles.lookup().findVirtual(String.class, "replace", mt);
String result = (String) mh.invokeExact("hello", 'e', 'a');

PerformanceOOP

Java · ExperteSnippet

Feingranulare Memory Barriers mit VarHandles

VarHandles bieten einen Standardweg für atomare Operationen und Memory Fencing. 'setRelease' stellt sicher, dass alle vorherigen Schreibvorgänge im aktuellen Thread für andere Threads sichtbar sind, die einen 'acquire' Load ausführen – effizienter als 'volatile' für spezifische Muster.

snippet.java

java

1

2

3

4

5

6

7

8

9

10

private static final VarHandle STATE_VH;
static { 
    try {
        STATE_VH = MethodHandles.lookup().findVarHandle(Node.class, "state", int.class);
    } catch (Exception e) { throw new Error(e); }
}
 
public void releaseState() {
    STATE_VH.setRelease(this, 1); 
}

PerformanceAsync & Concurrency

Java · ExperteSnippet

Deterministischer Off-Heap-Speicher mit der Foreign Function & Memory API

Die Foreign Function & Memory (FFM) API (Java 22+) bietet einen sicheren und effizienten Weg, auf Speicher außerhalb des Java-Heaps zuzugreifen. Im Gegensatz zu ByteBuffer nutzt sie 'Arenas' für ein deterministisches Lifecycle-Management und vermeidet GC-Overhead bei großen Datenmengen.

snippet.java

java

1

2

3

4

5

6

try (Arena arena = Arena.ofConfined()) {
    MemorySegment segment = arena.allocate(1024, 1);
    segment.setAtIndex(ValueLayout.JAVA_INT, 0, 42);
    int value = segment.getAtIndex(ValueLayout.JAVA_INT, 0);
    // Memory is released automatically when arena closes
}

Memory ManagementPerformance

Java · ExperteSnippet

Nested Record Patterns zur Datenextraktion

Record Patterns (Java 21) ermöglichen die tiefe Dekonstruktion komplexer Datenstrukturen direkt innerhalb von 'instanceof'- oder 'switch'-Anweisungen. Dies eliminiert Boilerplate-Casts und Accessor-Aufrufe, wodurch der Code deklarativer und weniger fehleranfällig wird.

snippet.java

java

1

2

3

4

5

6

7

8

public record Customer(String name, String email) {}
public record Order(Customer customer, double total) {}
 
void printOrderInfo(Object obj) {
    if (obj instanceof Order(Customer(var name, var email), var total)) {
        System.out.printf("Customer %s (%s) spent %.2f%n", name, email, total);
    }
}

SyntaxOOPBest Practices

Java · ExperteSnippet

Effizientes Stack-Walking mit der StackWalker-API

Die StackWalker-API ist eine performanceorientierte Methode zur Inspektion des Call-Stacks. Im Gegensatz zu Throwable.getStackTrace() bietet sie einen Stream-basierten Ansatz, der nur die benötigten Frames verzögert abruft, was sie ideal für Hochleistungs-Logging oder Sicherheitsprüfungen macht.

snippet.java

java

1

2

3

4

5

6

7

StackWalker walker = StackWalker.getInstance(StackWalker.Option.RETAIN_CLASS_REFERENCE);
 
Optional<String> caller = walker.walk(frames ->
    frames.skip(1)
          .findFirst()
          .map(StackWalker.StackFrame::getClassName)
);

PerformanceFehlerbehandlungBest Practices

Java · ExperteSnippet

Scoped Values für leichtgewichtiges Data-Sharing

Scoped Values (JEP 446) bieten eine moderne, threadsichere Alternative zu ThreadLocal. Sie wurden speziell für virtuelle Threads entwickelt und ermöglichen das effiziente, unveränderliche Teilen von Daten über Methodengrenzen hinweg, ohne den Speicher-Overhead und die Komplexität traditioneller Thread-Locals.

snippet.java

java

1

2

3

4

5

6

7

public final static ScopedValue<User> CURRENT_USER = ScopedValue.newInstance();
 
void processRequest(User user) {
    ScopedValue.where(CURRENT_USER, user).run(() -> {
        service.performTask(); // Inherits the value
    });
}

Async & ConcurrencyMemory ManagementBest Practices