David Vlijmincx on foojay.io - Friends of OpenJDK

Thread Safe Native Memory in Java

Tue, 07 Apr 2026 10:00:43 +0000

What is Memory Order and Why Does It Matter for Native Memory?

The Foreign Function and Memory (FFM) API is Java’s way of interacting with native code and memory. In the previous post, you learned how to do so using Java’s built-in Arena types. The Arena provides temporal safety and bounds checks, but what about thread safety? MemorySegments created by .ofShared(), .auto(), and .global() can be used by multiple threads at the same time. Using a VarHandle with just get/set can backfire if you don’t use something like locking. The downside is that locks are slow and heavy. So let us take a look at a more granular, hardware-aware approach: using VarHandle access modes.

Native Memory in Java: Arenas, Malloc, and Pools

Fri, 20 Mar 2026 10:20:04 +0000

What is the Memory API

The Foreign Function & Memory (FFM) API is Java’s new way of interacting with native code and memory. It is mostly useful when storing data off-heap or passing arguments to a native method. Handling this native memory comes down to balancing how much control you need against the risk of memory leaks. You can rely on the provided Arenas to bind memory to safe scopes, or you do it yourself using malloc and free for absolute control, or implement custom pools and slices to optimize allocations for your use case.

Pointer Arithmetic in Modern Java

Thu, 15 Jan 2026 09:00:12 +0000

Introduction

In this post, we dive into a more advanced topic: pointer arithmetic in Java. With the introduction of the Foreign Function & Memory API (Panama), we can interact with native memory.

Usually, when we work with off-heap memory, we use MemorySegment instances to ensure safety. However, creating these objects can sometimes add overhead. In this post, we will look at how to access native memory using addresses. The goal is to create fewer objects that are not strictly needed and only add GC pressure.

Benchmark and profiling Java with JMH

Tue, 24 Jun 2025 21:49:25 +0000

Introduction: Why JMH?

Performance matters in Java applications, but measuring it accurately is harder than you might think. I’ve seen countless developers try to measure performance by wrapping code in System.currentTimeMillis() calls or using simple timing loops, only to get misleading results due to JVM optimizations, garbage collection, or just mistakes during measurement.

The JVM is incredibly good at optimizing code, sometimes so good that it optimizes away the very code you’re trying to benchmark. Dead code elimination, constant folding, and just-in-time compilation can all skew your measurements in ways that don’t reflect real-world performance.

Async file IO with Java and io_uring

Fri, 18 Apr 2025 09:28:16 +0000

When I first started exploring Virtual Threads in Java, I wanted to understand everything about them like, performance characteristics, when they yield, and limitations. This journey led me to an interesting challenge about file I/O operations. These operations cause Virtual Threads to become “pinned” to platform threads, limiting their effectiveness for I/O-heavy applications.

This pinning issue has been widely acknowledged across the Java community. It’s mentioned in the Virtual Threads JEP , discussed on Reddit threads , debated on mailing lists , and highlighted in the “State of Loom ”. The consistent message: File I/O and Virtual Threads don’t play nicely together.