Graph/15003d55-09bb-4e3f-967a-39f66255440b

Domainunvalidated

Thread Safety

15003d55-09bb-4e3f-967a-39f66255440b

Thread Safety

Node Details

Public graph metadata

Updated5/1/2026

PageRank0.0000

Effectiveness0.000

Connections

25 linked nodes

PERTAIN_TOProblem

Secure random source: file:/dev/random java.security.egd: null — When I run printing out from within Java main method. Tension: I want to understand difference of `securerandom.source` vs `java.security.egd`. Outcome: I think you've hit the nail on the head.

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_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_TOAnswer

so-79575139

PERTAIN_TOProblem

The behavior is that I expected is that each threads enqueues and deques in the sequential order that the threads used in enqueue the values, but this is not the case. — using `built-in java ArrayBlockingQueue` and `custom implementation`. Outcome: q.add(...) and q.poll() may alternate.

PERTAIN_TOSolution

q.add(...) and q.poll() may alternate. — In your given code. Tension: there is no control over who poll() first to take out the head of the queue. Outcome: q.add(...) and q.poll() may alternate.

PERTAIN_TOAnswer

so-79431902

PERTAIN_TOProblem

the multithreaded version runs as long as the single threaded one — While writing a multithreaded application. Tension: I encountered a problem that the multithreaded version runs as long as the single threaded one.

PERTAIN_TOSolution

So I change to `ThreadLocalRandom`. — I realize that I use `java.util.Random` shared between threads. Outcome: there's ThreadLocal, which does have a seed value but each thread has its own completely independent rng and seed.

PERTAIN_TOAnswer

so-79276858

PERTAIN_TOProblem

Suppose #0 reads `strong == 1`. That requires: Both `fetch_sub` operations (#2 and #3) have already happened before #0. Tension: Threads that "shouldn't" modify the counter get stuck before performing the release operations that would allow #0 to see a reduced count. Outcome: So the uniqueness test is valid and future-proof.

PERTAIN_TOSolution

#2/#3 `fetch_sub(release)` → #0 `load(acquire)`. Outcome: your analysis matches what Rust relies on.

PERTAIN_TOAnswer

so-79835201

PERTAIN_TOProblem

calling `.notify_one()` / `.notify_all()` on a destructed `std::atomic` is UB — This also applies to `std::atomic_ref`. Tension: the object it points to must outlive the `std::atomic_ref` object. Outcome: There are workarounds, depending on your usecase.

PERTAIN_TOSolution

There are workarounds, depending on your usecase — calling `.notify_one()` / `.notify_all()` on a destructed `std::atomic`. Tension: There is a C++ Paper - P2616R4 - which would fix this problem. Outcome: using `std::binary_semaphore` delegating `.wait()` and `.notify_xxx()` to a separate atomic variable that has a longer lifetime manually call the futex syscalls and bypass the stdlib.

PERTAIN_TOAnswer

so-79809560

PERTAIN_TOProblem

what are the correct values of three highlighted parameters? — when it comes to intrusive lockless stacks (single-linked lists). Tension: I've seen various permutations of highlighted parameters. Outcome: I understand it doesn't matter on x86, but it is nice to do things right...

PERTAIN_TOSolution

node* p = head_.load(std::memory_order_acquire); // acquire is necessary — while (p && !head_.compare_exchange_weak(p, p->next,. Outcome: `CAS_weak(p, p->next, acquire, acquire)`.

PERTAIN_TOAnswer

so-79795410

PERTAIN_TOProblem

this does not happen — whenever the tracee creates a new thread. Tension: I must also follow all threads created by the traced program.

PERTAIN_TOSolution

To get the effect you want. Tension: you're not resuming the parent before you wait for the child!

PERTAIN_TOAnswer

so-79778462

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.

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