Tagged articles
race condition
32 articles · Page 1 of 1
Linus Torvalds, after calling AI 90% hype, used Claude Code to implement an RCU-based fix for Linux kernel page cache contention that tripled throughput and cut cache-line bouncing by 99.6%, but kernel reviewers discovered a subtle race condition causing silent data corruption, requiring a human rewrite.
Claude CodeConcurrencyLinus Torvalds
0 likes · 12 min read

This article explains Linux process states (TASK_RUNNING, TASK_INTERRUPTIBLE, TASK_UNINTERRUPTIBLE), the schedule() and wake_up_process() mechanisms, the lost wakeup race condition that occurs when a process checks a condition before setting its sleep state, and the correct pattern used in the Linux kernel—setting the state to interruptible before condition checking and looping with schedule()—to avoid indefinite sleep.
Linux kernelProcess SchedulingTASK_INTERRUPTIBLE
0 likes · 14 min read

This article demonstrates how to prevent race conditions between order timeout closure and payment callbacks using atomic conditional UPDATE statements and SELECT FOR UPDATE with a refund outbox pattern, ensuring either payment wins and order becomes PAID, or closure wins and late payments trigger automatic refund compensation.
InnoDBMySQLSpring Boot
0 likes · 11 min read

This article demonstrates how Java's final keyword enables immutable objects that remove the need for synchronization in concurrent code, using a config hot-reload example that shows race conditions in mutable objects and zero errors with immutable design.
ConcurrencyJavaJava 17 records
0 likes · 12 min read

This article introduces thread safety by explaining threads, shared memory, and thread switching, then demonstrates a race condition where a Java counter loses increments due to non-atomic count++, and shows how synchronized fixes it by serializing access.
Java ConcurrencyShared MemorySynchronized
0 likes · 11 min read

Security researchers disclosed CVE‑2026‑68138, a race‑condition flaw in the Linux kernel’s qdisc rate‑table code that lets an unprivileged user gain a root shell within seconds; it affects Linux 5.1‑7.1.5, has a publicly available PoC, and can be mitigated by applying upstream patches or disabling unprivileged namespaces.
CVE-2026-68138Linux kernellocal privilege escalation
0 likes · 9 min read

The article explains processes as independent execution units and threads as lightweight CPU‑scheduled workers, using a boss‑and‑employees metaphor, code samples in Python and Java, practical scenarios, common pitfalls like race conditions and deadlocks, and guidance on when to choose multiprocessing versus multithreading.
ConcurrencyMultithreadingParallelism
0 likes · 9 min read

To trigger an Xbox 360 race‑condition exploit, the researcher reverse‑engineered four hard‑drive models, extracted and analyzed their firmware, used JTAG and vendor‑specific commands to locate the DMA READ EXT handler, injected a 200 ms delay loop, and ultimately found the exploit works without any firmware modification.
JTAGXbox 360embedded security
0 likes · 13 min read

The article explains that idempotency guarantees result correctness but does not control concurrent execution order, while distributed locks serialize access; through code examples and scenarios like stock deduction and money transfer it shows why both mechanisms are complementary and often needed together.
Distributed LockIdempotencyJava
0 likes · 10 min read

On June 9, 2026, security researcher Nightmare Eclipse released the RoguePlanet zero‑day exploit that leverages a race condition in Microsoft Defender to spawn a SYSTEM‑level command prompt on Windows 10/11 machines fully patched with the June updates, while also hinting at a possible BitLocker bypass.
BitLocker bypassMicrosoft DefenderRoguePlanet
0 likes · 10 min read

The article walks readers through Go's concurrency model, explaining lightweight goroutines and channel communication, demonstrates common patterns such as worker pools and fan‑in/fan‑out with concrete code, highlights typical pitfalls like race conditions, deadlocks and memory leaks, and offers practical best‑practice recommendations for safe concurrent programming.
ConcurrencyGoWorker Pool
0 likes · 10 min read

This comprehensive guide explains why race conditions occur in Linux processes, explores the underlying concepts of critical sections and synchronization, and provides practical examples of atomic operations, mutexes, semaphores, condition variables, read‑write locks, and spinlocks to ensure safe concurrent programming.
C++MutexPOSIX
0 likes · 39 min read

This article dissects a common React interview snippet that uses useEffect for data fetching, exposing hidden pitfalls such as component unmount updates, request race conditions, and missing error handling, and then presents a robust solution with cleanup logic and proper error management.
Frontend InterviewReactState Management
0 likes · 8 min read

This analysis of the October 2025 AWS US-EAST-1 outage details how a race condition in DynamoDB's automated DNS management system caused DNS resolution failures, triggering a 12-hour EC2 congestion collapse due to lease backlog and an NLB health-check failover driven by stale network configuration.
AWSDNSDynamoDB
0 likes · 11 min read

At Meta Connect 2025, Meta's ambitious showcase of three new smart glasses and a neural wristband backfired with two high‑profile demo failures—one caused by a self‑inflicted DDoS from simultaneous device requests and the other by a race‑condition bug that put the HUD to sleep—turning a potential breakthrough into a public embarrassment.
AIDDoSMeta
0 likes · 8 min read

Embedded firmware bugs such as race conditions and non‑reentrant functions are hard to reproduce, but by understanding their causes, using atomic operations, mutexes, and clear naming conventions, developers can systematically identify, avoid, and mitigate these hidden errors in RTOS‑based systems.
Best PracticesRTOSnon-reentrant
0 likes · 7 min read

This article provides a comprehensive guide to Go's concurrency model, covering goroutine creation, the scheduler, synchronization primitives such as WaitGroup, atomic operations, mutexes, and both unbuffered and buffered channels, with practical code examples and explanations of race conditions and best practices.
ChannelsConcurrencyGo
0 likes · 25 min read

The article explains the distinction between a data race—simultaneous unsynchronized memory access by goroutines—and a race condition—logic errors caused by timing dependencies—using Go code examples, demonstrates how to reproduce each issue, and shows how mutexes or atomic operations can resolve them.
ConcurrencyData RaceGo
0 likes · 5 min read

This article walks through Go's concurrency model, detailing how goroutines are scheduled across logical processors, how to control parallelism with GOMAXPROCS, detect and resolve race conditions using atomic operations, mutexes, and channels, and provides practical code examples for each concept.
ChannelsConcurrencyGo
0 likes · 18 min read

This article explains common multithreading problems such as race conditions, deadlocks, resource contention, and data consistency issues, and provides Python code examples that demonstrate synchronization techniques, lock ordering, connection pooling, thread pools, and transaction management to ensure correct and stable concurrent execution.
Data ConsistencyMultithreadingPython
0 likes · 10 min read

Bilibili tackled race‑condition vulnerabilities in its massive video content pipeline by replacing simple timestamp checks with optimistic locking (CAS) and rate‑limiting locks, adding version verification and observation tools that now eliminate missed reviews and improve security, scalability, and real‑time editing reliability.
BilibiliConcurrencyContent moderation
0 likes · 10 min read

This article explains Go's concurrency model, detailing how goroutines are scheduled onto logical processors, how to create and run them, handle race conditions with atomic operations, mutexes, and the race detector, and share data safely using unbuffered and buffered channels with practical code examples.
GoMutexatomic
0 likes · 19 min read

This article outlines five typical errors that plague embedded firmware—race conditions, non‑reentrant functions, missing volatile qualifiers, stack overflows, and heap fragmentation—and provides concrete best‑practice guidelines to detect, avoid, and mitigate each issue.
Reentrancyfirmwarerace condition
0 likes · 13 min read

This article explains essential techniques for managing concurrent access and race conditions in PHP, covering mutex locks, semaphores, atomic operations, queue-based processing, database access optimization, and transaction management to improve system reliability and performance.
ConcurrencyMutexPHP
0 likes · 5 min read

This article explains why asynchronous data fetching in React can cause race conditions that lead to flickering or mismatched content, and presents several practical solutions—including component remounting, data validation, cleanup effects, and request cancellation—to ensure reliable UI updates.
AbortControllerData Fetchingrace condition
0 likes · 16 min read

This article explains what race conditions are, demonstrates how they can occur in React components during asynchronous data fetching, and provides practical solutions using component lifecycle checks, boolean cancellation flags, the ahooks useRequest hook, and React Suspense to ensure correct UI updates.
race conditionuseEffectuseRequest
0 likes · 9 min read

This article explains what race conditions are in front‑end web development, demonstrates the issue with a React demo fetching articles, and walks through step‑by‑step solutions using custom hooks, useEffect cleanup, and AbortController to safely cancel outdated requests and avoid stale data rendering.
AbortControllerCustom HookData Fetching
0 likes · 10 min read

This article demonstrates how to use RxJS Observable to build robust front‑end anti‑corruption layers, covering stability improvement, splash‑screen timing, automatic fast‑API selection, race‑condition handling, and high‑order data composition with practical code examples and online demos.
Anti-Corruption LayerData compositionRetry
0 likes · 12 min read

After noticing abnormal memory usage in a production service, the author traced a leak to a race condition in shared data during a C++ code refactor, demonstrated the debugging steps, explained why traditional tools like Valgrind help, and shared lessons on avoiding multithreaded memory leaks.
C++Debuggingrace condition
0 likes · 10 min read

This article explains why Python's OS‑level threads can be slower for CPU‑bound tasks due to the Global Interpreter Lock, describes race conditions caused by reference counting, and shows how using threading locks (including context‑manager syntax) ensures correct concurrent execution.
ConcurrencyGILLock
0 likes · 6 min read

Even when using thread‑safe classes like Java's ConcurrentHashMap, combining multiple thread‑safe methods into a single operation can still cause race conditions, as demonstrated by a test where two threads concurrently execute get‑and‑put logic, leading to an unexpected map value and a failed assertion.
ConcurrencyConcurrentHashMapJava
0 likes · 3 min read

The article recounts a four‑year investigation that uncovered and repaired a subtle race‑condition bug in Python's Global Interpreter Lock, detailing the bug's origin, the implemented fixes, performance testing, and the decision to make the GIL creation unconditional in Python 3.7.
CPythonGILPython
0 likes · 10 min read
