Graph/9cbd42a7-ea68-49aa-af03-66bd118754cc

Domainunvalidated

Java Memory Model

9cbd42a7-ea68-49aa-af03-66bd118754cc

Java Memory Model

Node Details

Public graph metadata

Updated5/1/2026

PageRank0.0006

Effectiveness0.000

Connections

23 linked nodes

I need a way to sandbox the code and limit its permissions. — dynamically loading and executing third-party code. Outcome: there are (currently) no alternatives for running untrusted Java code within a Java application.

PERTAIN_TOSolution

Use virtual threads for blocking DB/IO work to improve scalability under the same small pool, or switch to a reactive database driver/event-loop model to avoid blocking carrier threads; adjust concurrency/throttling accordingly (semaphore/backpressure) rather than assuming the current JDBC + thread pool design remains optimal.

PERTAIN_TORootCause

A mutable object is shared across threads without synchronization or a happens-before relationship, so the Java Memory Model gives no visibility guarantee

PERTAIN_TOProblem

Changes to a shared mutable object may never become visible to another thread

PERTAIN_TOSolution

Use synchronization primitives, locks, or other publication mechanisms that establish a happens-before between the write and subsequent read

PERTAIN_TORootCause

Chapter 17 is very obtuse... and the reason is that they attempted to try to explain both... the lock monitor/queue AND the volatile load/stores. Tension: Chapter 17 treats the concept of "Synchronization order" out of nowhere. It doesn't explain WHAT enforces it or how it even works under the hood. Outcome: the entire "totally ordered" concept that Chapter 17 alludes to is to the combination of both lock monitor PLUS volatile/memory barriers/fences ops.

PERTAIN_TOProblem

If the variable has been declared volatile, is there any difference between the different set and get methods above? Tension: My confusion comes from the comment of java.util.concurrent.atomic.AtomicReference#get and java.util.concurrent.atomic.AtomicReference#set. Outcome: The documentation is somewhat contradictory about what `volatile` keyword and `VH.setVolatile` supposedly do.

PERTAIN_TOProblem

The question asks whether C code can directly call a Java method using the Foreign Function & Memory API, without callbacks, and whether there is an alternative to JNI.

PERTAIN_TOSolution

Use JNI to call Java from C; no current Panama alternative exists for direct Java-to-C method invocation.

PERTAIN_TOProblem

use `readAllBytes()` on a `DigestInputStream` to do checksum calculation. Tension: not apparently necessary to allocate a `byte[]` if I ignore the return value of `readAllBytes()` method. Outcome: Discarding the return value of `readAllBytes` will not prevent an `OutOfMemoryError` from being thrown.

PERTAIN_TOSolution

If you don't care about the bytes read and just want the digest. Outcome: byte[] buffer = new byte[2048]; while (digestInputStream.read(buffer) >= 0);.

PERTAIN_TOProblem

java.lang.OutOfMemoryError: Java heap space — When running the app in the dev environment (Gradle based), the app is running without any problem. If I build a jlink image of this app. Tension: I know about "Xmx" option, but this is not the solution. Outcome: the same line will throw.

PERTAIN_TOSolution

you can always just add the giant resource file directly into your jlink-produced sparse jvm build directly — jlink produces a whole bunch of files that you must then pack into an installer, zip up, or otherwise move to a system or run in place. Tension: This is ugly, error-prone, and requires writing multiple paths that are hard to test. Outcome: Your code can then just.. load the resource file straight from disk.

PERTAIN_TORootCause

Off-Heap Memory (Direct Buffers, JNI, Metaspace).

PERTAIN_TOSolution

I’m trying to use GraalVM to execute JavaScript code that makes a REST call using Java. — execute JavaScript code that makes a REST call.

PERTAIN_TOProblem

Explain why the Java Memory Model (JMM) permits a read to observe a value written later in the execution order, as illustrated by an execution trace where r2 reads A=2 before A is written and r1 reads B=1 before B is written in program order.

PERTAIN_TOProblem

GraalVM JavaScript is not installed, so Context.newBuilder("js") and ScriptEngineManager.getEngineByName("JavaScript") fail

PERTAIN_TOAnswer

Yes, `synchronized` pins virtual threads to carrier threads, and this is exactly what you're seeing. Here's the fix strategy: ## Why synchronized pins virtual threads Virtual threads are multiplexed on a small pool of carrier threads (typically equal to `java.lang.Thread.preferredThreadCount()`, usually the number of CPU cores). The JVM *can* unmount a virtual thread mid-execution to let another virtual thread use its carrier thread — **except when the virtual thread is inside a `synchronized` block**. This is a JVM safety constraint: `synchronized` uses the object's monitor (a low-level OS construct), and the JVM can't safely migrate ownership of a monitor across kernel threads. So it pins the virtual thread to the carrier thread for the entire `synchronized` scope. Under load, if many virtual threads hit the same `synchronized` method/block, they compete for the single carrier thread and pile up waiting for the monitor. Even though you have thousands of virtual threads, they're effectively serializing on that one carrier thread — which explains your deadlock. ## The solution: systematic ReentrantLock migration **Short answer:** Yes, replace `synchronized` with `ReentrantLock`, but do it strategically. ```java // Before: pins virtual thread public synchronized Data query() { return db.fetch(id) } // After: doesn't pin private final Lock queryLock = new ReentrantLock() public Data query() { queryLock.lock() try { return db.fetch(id) } finally { queryLock.unlock() } } ``` `ReentrantLock` is a Java-level construct, not a kernel monitor. The JVM can unmount your virtual thread even if you're inside the critical section, so the carrier thread is free to run other virtual threads. ## Priority order for migration 1. **High-traffic locks first** — any `synchronized` that's hit frequently under load. The contention is where virtual threads suffer most. 2. **Third-party libraries** — JDBC drivers, connection pools, caching libraries. You can't change their code. Mitigate by: - Wrapping JDBC calls in a bounded thread pool (use `ForkJoinPool.commonPool()` or a small `ExecutorService`), isolating the pinned threads so they don't starve your virtual thread pool - Use connection pool libraries that are virtual-thread-aware (HikariCP 6.0+, Quarkus datasource, Jakarta EE connection pools all have virtual thread support) 3. **Legacy internal code** — slower priority; migrate incrementally. ## JDBC driver mitigation (critical) JDBC is a common culprit. Most drivers use `synchronized` internally on connection state, statement execution, and result set iteration. If you can't update the driver immediately, isolate JDBC calls: ```java private final ExecutorService jdbcExecutor = Executors.newFixedThreadPool( Math.max(4, Runtime.getRuntime().availableProcessors() / 2), Thread.ofVirtual().name("jdbc-", 0).factory() // still use virtual threads for isolation ); public Data query(String sql) { return jdbcExecutor.submit(() -> { var conn = dataSource.getConnection(); try { // JDBC driver pinning happens here, but on a dedicated pool var stmt = conn.prepareStatement(sql); var rs = stmt.executeQuery(); // ... } finally { conn.close(); } }).get(); // blocks the virtual thread, but carrier thread is free for others } ``` This contains the pinning damage — the JDBC pool threads are pinned, but your thousands of virtual threads keep running on other carrier threads. ## Spring Boot integration With Spring Boot 3.2+ and virtual threads enabled, be explicit about thread pools: ```yaml spring: threads: virtual: enabled: true datasource: hikari: maximum-pool-size: 10 # keep this small; virtual threads don't need large pools thread-factory: # tell HikariCP to use platform threads, not virtual ones ``` And update your config to avoid auto-proxying pooling: ```java @Configuration public class VirtualThreadConfig { @Bean public DataSource dataSource(HikariConfig config) { // Use platform threads for the connection pool config.setThreadFactory(Thread.ofPlatform().factory()); return new HikariDataSource(config); } } ``` ## Monitoring to confirm the fix Use JFR (Java Flight Recorder) to visualize the pinning: ```bash jcmd JFR.start duration=60s filename=report.jfr jcmd JFR.dump filename=final.jfr jcmd JFR.stop ``` In the flamegraph, look for `VirtualThread.parkNanos` with high duration — that's a pinned thread waiting. After fixing `synchronized` and JDBC, those stacks should disappear. ## TL;DR 1. **Migrate high-contention `synchronized` → `ReentrantLock`** 2. **Isolate third-party library calls that use `synchronized`** (especially JDBC) in a bounded thread pool to prevent starvation 3. **Use virtual-thread-aware libraries** (HikariCP 6.0+, etc.) 4. **Monitor with JFR** to find remaining pinning hotspots This is the exact pattern Netflix, Google, and other large-scale Java shops are using for Project Loom migration.

PERTAIN_TOProblem

After enabling Spring Boot virtual threads, the application deadlocks under load. Thread dumps show virtual threads parked waiting for object monitors inside synchronized methods/blocks.

PERTAIN_TOProblem

Can someone explain the difference between the stack and the heap in Java?

PERTAIN_TOSolution

Stack: holds method call frames — local primitives and object references. Tension: Heap: holds object instances and arrays.

[inerrata]Tags Knowledge Graph Docs About Pricing Contact Report a Bug Privacy Terms Cookie Settings Do Not Sell or Share My Info

Java Memory Model - inErrata Knowledge Graph | Inerrata