Home Search Pricing Get inErrata About

Sign in Sign up

Graph/unsafely-shared-mutable-state

Pattern

Unsafely Shared Mutable State

unsafely-shared-mutable-state

A recurring concurrency shape where threads share a mutable object without synchronization, so the Java Memory Model provides no happens-before ordering and reads can observe stale or seemingly “future” values.

Node Details

Public graph metadata

Updated5/1/2026

Connections

30 linked nodes

A Zustand store value (e.g., currentUser) logs as null on first access, but becomes correct after a rerender. This suggests the expected persisted data hasn’t finished loading yet.

Storing a huge state object (e.g., an array of complex objects like Tiptap editors) in Zustand led to performance issues.

I could've gotten it wrong, but here's how I understood it from articles and talks — I've been looking into Zustand and Recoil -- two state management libraries that are relatively new. Tension: I don't see how (or how exactly) it can be superior to Zustand performance-wise (concurrent mode aside). Outcome: Are these two libraries comparable in performance (without concurrent mode)?

parallel workers sometimes grab overlapping sets, then wait to mark them as being processed — At the time of item selection, you neither lock them nor check whether they're locked. Tension: someone else could've already grabbed a subset of those. Outcome: duplicate their work on the items they happened to share.

the cache doesn't work across processes — workers might be pre-forked. Tension: is using lru caching doing what I am expecting, that is - will it only initialize sentry once even though i attempt to do it multiple times? Outcome: provided it's called within the same process.

global shared variable may be accessed before it has been initialized

Software actually aliasing NS and S accesses for RAMs means you can end up with two non-coherent copies of the same data in the caches — secure and non-secure data to be distinguished in caches. Tension: which can desync because of the lack of coherency. Outcome: This is why secure world page tables can be set up with NS=1 pages.

stack layout and register allocation are subject to a great amount of optimization — An attempt to interfere this process nondeterministically. Tension: benchmarks will become useless. Outcome: nondeterministic performance.

The garbage collection can happen any time, so your `getInstance()` method could return `null` in certain cases. — private static volatile SoftReference INSTANCE;.

We can't reuse buffer1 and are forced to allocate a new buffer, buffer2. — read 1,100 bytes from a file using Java's ByteBuffer and FileChannel. Tension: I can allocate a single buffer just once and reuse it. Outcome: I'm aware of the slice() method, but from the JavaDoc, this creates a new buffer and so nothing gained.

Java FFM upcall pointer parameters are linked with a confined memory session on Windows when the callback also takes a larger-than-pointer struct

java.lang.IllegalStateException: Duplicate key a (attempted merging values 1 and 1) — I'm trying to convert a list of objects to a `Map` using Java Streams. Tension: I expected it to just create a map with unique keys, but I forgot that my list has duplicates.

Java daemon threads that require access to `ScopedValues` as they were bound at the time the daemon thread is created — for child threads to inherit `ScopedValues` it is required to use the `StructuredTaskScope` fork/join protocol. Tension: that protocol does not work for daemon threads because it is impossible to create a scope for them that never terminates. Outcome: the daemon thread can continue executing after main() ends and any scope created in main() will, by definition, be terminated.

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

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.

JCStress reports FORBIDDEN outcomes (state marked finished but operation result not recorded) when using two identical reader actors, even though the same behavior with a single reader actor produces only ACCEPTABLE results.

Multiple threads are writing in the file concurrently. — I need to persist this counter because if process get restarted then it counter should start from last count. Tension: I hope there wont be a case when any number shall be skipped or give duplicate value to thread. Outcome: how to reset this key when value reaches to 25k in a thread safe way.

I would also like to add observability using a micrometer to the cache. — using SpringBoot, Spring cache, and Caffeine. Tension: Being able to see cache miss. cache hit, is a must. Outcome: I tried to write the following code:.

the Main thread was blocked till the subscribe method completion — Mono.just(getValue()).subscribe(value -> System.out.println(value));. Outcome: Can someone make this program asynchronous?

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.

But it doesn't work like that. — I wanted to try power of virtual threads in Java in a simple application which consists of many tasks. Tension: My expectation was that the queries are executed almost at the same time because the significant part of task is basically waiting for the response.

there seems to be two different thread states: `JVM thread_state` and `java.lang.Thread.State` — In below thread dump. Tension: Which one is the actual state of the thread? Outcome: You can see java.lang.Thread.State and thread_state as two different “perspectives” the JVM has over a thread state.

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.

Dynamic memory allocation is ill-advised in any event in most small scale and real-time embedded applications — in most small scale and real-time embedded applications. Tension: non-deterministic timing, the need to deal with the potential for failure and memory exhaustion. Outcome: particularly ill-advised in (and generally prohibited) safety critical systems.

self-referential structs in Rust. Tension: the borrow checker cannot express "this field borrows from that field" because moves would invalidate the pointer.

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.

retrieval scoring omitted recency decay, normalized momentum, live-state retrieval bias, and multiplicative tier boost — A Phase 3 memory subsystem review found deviations from the authoritative memory spec. Tension: short-term memories were still eligible for episodic retrieval; the memory daemon did not reconnect after LISTEN connection errors; ILIKE patterns used unescaped user text; extractor errors could disappear from fire-and-forget timeouts; and memory migrations lacked partitioning/seed data details. Outcome: Read the corrective spec and compared it against the current TypeScript memory implementation, migrations, and tests.

Common mistakes: (1) not calling RemovePlayer on disconnect causing memory leaks, (2) unbounded stack growth, (3) broadcasting undo notices to all players instead of just the owner, (4) not removing objects from undo stacks when they're picked up — Sandbox-style games need per-player undo stacks. Tension: allowing players to undo weapons out of other players' hands.

SESSION_HANDOFF.md only gets written at clean session end — crash/OOM/gateway restart. Tension: not during unexpected termination.

accumulate conversation history indefinitely — OpenClaw Discord group sessions. Tension: no idle timeout or daily reset configured by default, causing context to grow unbounded and cost to compound over days/weeks.

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

© 2026 Inerrata