This article explores Java's thread‑local storage, explaining why shared variables cause thread‑safety issues, how a proxy can hide object retrieval, the pitfalls of a naive Map‑based design that leads to memory leaks, and how the JDK's ThreadLocal uses weak references and ThreadLocalMap to safely manage per‑thread data.
Java's synchronized keyword provides mutual exclusion by using object monitors, offering class‑method, static‑method, and block locking patterns, while the JVM optimizes performance through biased, lightweight, and heavyweight lock strategies, making it essential knowledge for efficient concurrent programming.
This article dives deep into Java's ConcurrentHashMap, explaining how it uses CAS, volatile fields, lock‑striping and cooperative resizing to provide thread‑safe get, put and size operations while maximizing concurrency and performance.
The article explains Java's synchronized containers such as Vector, Stack, and Hashtable, demonstrates their usage and pitfalls, then introduces concurrent containers like ConcurrentHashMap, CopyOnWriteArrayList, and ConcurrentSkipListSet, providing code examples and best practices for thread‑safe collection handling.
The article compares Java's pessimistic locking mechanisms such as synchronized blocks and ReentrantLock with optimistic approaches like version checks, CAS‑based AtomicInteger and custom spin locks, illustrating each method through counter examples and discussing their performance trade‑offs and limitations.
This article introduces Java's ReentrantLock as an easy-to‑use alternative to synchronized, explains its core lock() and unlock() methods, demonstrates practical code examples, and covers advanced APIs such as tryLock, getQueueLength, isLocked, and getHoldCount for robust multithreaded programming.
This article explains Go's sync.Once primitive, compares it with init, details various singleton implementations—including lazy, eager, and double‑checked locking—and provides practical code examples and a deep dive into its source implementation for thread‑safe one‑time initialization.
This article explains the thread‑unsafe nature of Java’s ArrayList, HashSet and HashMap, details their internal implementations and growth mechanisms, and presents three common solutions—Vector, synchronized wrappers, and CopyOnWrite collections—to achieve thread safety in concurrent environments.
This article explains how variable sharing in multithreaded Java programs leads to thread‑unsafe behavior, explores the JVM memory model and stack frame structure, and demonstrates practical ways to achieve thread safety by keeping variables thread‑local or using proxy objects.
This article explains how to implement simple counters in Python, demonstrates why a naïve single‑thread counter is not safe for concurrent use, and presents three thread‑safe alternatives—using a lock, leveraging the GIL with itertools.count, and a combined fast‑read/fast‑write design—along with a performance comparison.
This article explains the two primary use cases of ThreadLocal in Java—providing each thread with its own exclusive object and sharing request‑scoped data across methods—while covering implementation details, memory‑leak risks, and best‑practice cleanup techniques.
This article explains that Spring MVC controllers are singleton by default, illustrates the thread‑safety problems caused by shared instance variables with concrete code examples, and provides practical solutions such as avoiding state, using prototype scope, ThreadLocal, or AtomicInteger to make controllers safe under high concurrency.
This article explains Java 1.8 ConcurrentHashMap’s default capacity, null‑key/value restrictions, resizing behavior, internal array‑list‑tree structure, node fields, put and get processes, thread‑safety mechanisms, iterator consistency, and differences between JDK 7 and JDK 8 implementations.
This article explains why Redis can encounter thread‑safety‑like problems, how network latency limits its performance, and how embedding Lua scripts lets you create atomic, server‑side commands that overcome these issues while providing practical code examples.
This article explains the differences between stateful and stateless Spring beans, the impact of singleton and prototype scopes on thread safety, and demonstrates how ThreadLocal can be used to safely share resources in multithreaded backend applications, complete with code examples.
This article explains the Java Memory Model, how threads interact with main and working memory, and details the happens‑before rules—including program order, monitor, volatile, thread start, join, and transfer—to help developers understand visibility and ordering challenges in concurrent Java programs.
A Java multithreading example shows that synchronizing on a mutable Integer field does not guarantee exclusive access, and the article explains the root cause, demonstrates correct locking techniques, and offers best‑practice tips for safe concurrent programming.
This article explains why StringBuilder is not thread‑safe, demonstrates the problem with a multithreaded example that produces a wrong length and occasional ArrayIndexOutOfBoundsException, and shows how StringBuffer’s synchronized implementation avoids these issues.
This article provides an in-depth exploration of Java concurrency and synchronization mechanisms, detailing the evolution of the Java Memory Model, explaining core concepts like volatile, CAS, synchronized, and park/unpark, and illustrating their practical applications through code examples and JVM optimization insights.
This article explains why SimpleDateFormat is not thread‑safe in Java, demonstrates the problem with multithreaded examples, and presents five practical solutions—including local variables, synchronized blocks, explicit locks, ThreadLocal, and the modern DateTimeFormatter—along with their advantages and drawbacks.
This article explains why ThreadLocal is both simple and tricky to use, demonstrates common pitfalls when formatting dates with SimpleDateFormat in multithreaded environments, analyzes thread‑safety issues, and provides practical solutions using synchronized blocks, ThreadLocal, and its advanced initialization methods for clean and efficient concurrent code.
This article examines how adding Java thread‑safe classes and the synchronized keyword influences QPS in performance testing, presenting code modifications, benchmark results for 20 and 40 threads, and concluding that their impact on measured throughput is minimal.
This article explains Java thread safety by defining it, breaking down atomicity, visibility, and ordering, illustrating core concepts with AtomicInteger and AtomicStampedReference examples, and detailing the underlying CAS mechanisms, JMM rules, and the ABA problem.
This comprehensive guide introduces Java concurrency fundamentals, explains common tools and their underlying principles, discusses typical challenges such as thread safety, visibility, and ordering, and provides practical code examples and optimization techniques for building high‑performance multithreaded applications.
This article explains the thread‑safety differences between StringBuilder and StringBuffer, demonstrates the problems of using mutable shared objects in multithreaded Java code, presents three solutions, and discusses why Servlets are not thread‑safe by default, highlighting visibility and ordering concepts.
This article provides a comprehensive overview of Java's collection framework, detailing the roles of interfaces, implementations, and algorithms, comparing collections with arrays, describing common List, Set, and Map classes, their underlying data structures, thread‑safety characteristics, and best practices for iteration and usage.
The article explains Java's String immutability, shows how concatenation creates new objects, and discusses the design reasons—caching, security, thread‑safety, hash‑code caching and performance—while recommending mutable alternatives like StringBuilder for modifiable text.
This article explains why Java's HashMap is unsafe in multithreaded environments, detailing how JDK 1.7's resize operation can create circular linked lists and data loss, and how JDK 1.8's tail‑insertion still suffers from element overwriting under concurrent puts.
This article explains practical techniques for generating varied request parameters—such as random numbers, thread‑safe identifiers, random strings, and upstream data extraction—to avoid identical inputs in multi‑call performance tests and improve test reliability.
This article explains various Java singleton implementations—including eager, lazy, double‑checked locking, static inner class, and enum—demonstrates their thread‑safety issues, shows how reflection and serialization can break them, and presents the enum approach as a truly safe solution.
This article explains why Spring MVC controllers are singleton by default, demonstrates the thread‑safety issues caused by non‑static member variables, shows how applying @Scope("prototype") changes behavior, and summarizes the five Spring bean scopes with practical recommendations.
This article explains why Java's ArrayList is not thread‑safe, illustrates the two main concurrency problems—array index out‑of‑bounds and element overwriting—through source‑code analysis and multithreaded examples, and presents several practical solutions such as synchronized wrappers, explicit locking, CopyOnWriteArrayList and ThreadLocal.
This article explains how Java's ThreadLocal class provides a thread‑local storage mechanism that creates independent object instances for each thread, improving scalability and performance compared to synchronized blocks, and demonstrates its usage with practical code examples and best‑practice guidelines.
This article explains the fundamentals of spin locks, introduces the CLH lock as an improved spin‑lock variant, analyzes its Java implementation details, and describes how Java's AbstractQueuedSynchronizer refactors CLH locks to provide fair, low‑overhead synchronization for concurrent applications.
This article explains how to modify a Java search API and write custom performance‑testing scripts that embed unique request marks, enabling precise measurement of each request's response time when header‑based marking is unavailable.
This article explains the internal design of Java's ConcurrentHashMap, covering its evolution from JDK7 to JDK8, the segment‑based locking mechanism, lock‑free reads, CAS operations, table resizing, treeification, and the key classes and methods that enable efficient concurrent access while maintaining thread safety.
This article explains why Spring beans are not inherently thread‑safe, compares the singleton and prototype scopes, shows how stateless beans can be safe, demonstrates the impact of static fields and injected beans, and provides practical code examples and recommendations for achieving thread safety in Spring applications.
This article outlines the essential design points for building a local Java cache—including data structures, size limits, eviction policies, expiration handling, thread safety, blocking mechanisms, simple APIs, and optional persistence—while providing concrete code snippets and implementation guidance.
The article uses a casual conversation between two backend engineers to introduce multithreading concepts, explain shared vs. private resources, define thread‑safe and reentrant functions, illustrate common pitfalls with code examples, and provide practical guidelines for writing correct concurrent C++ services.
This article outlines the essential design considerations for building a local cache—such as data structures, size limits, eviction policies, expiration, thread safety, simple APIs, persistence, and blocking mechanisms—and demonstrates concrete Java implementations with code examples.
This article explains the definition, class diagram, and multiple Java implementations of the Singleton pattern—including eager, lazy, double‑checked locking, static inner class, and enum approaches—while discussing thread safety, volatile usage, and practical considerations.
This article outlines eight practical Java approaches—including stateless design, immutability, safe publication, volatile fields, synchronized blocks, explicit locks, CAS operations, and ThreadLocal—to guarantee data safety in multithreaded environments, explaining each concept and providing concise code examples.
This article explains the concepts of spin locks and mutex locks, introduces the CLH lock as a fair spin lock used in Java's AbstractQueuedSynchronizer, and provides a detailed walkthrough of its Java implementation, initialization, lock and unlock processes, along with code examples and visual illustrations.
This article explains why the i++ operation is not thread‑safe in Java, examines how the volatile keyword affects variable visibility, demonstrates the problem with concrete code examples, and shows how to solve it using synchronized blocks or the java.util.concurrent.atomic classes.
This article explains the fundamentals of HashMap, then dissects the internal fields, node‑array safety, read‑path guarantees, write‑path locking, atomic compute methods, resize‑transfer mechanics, traverser design, and bulk‑task support that together make Java's ConcurrentHashMap (C13Map) a highly concurrent, lock‑free data structure.
Although StringBuilder and StringBuffer share similar APIs, StringBuilder lacks thread safety because its append method updates shared fields without synchronization, leading to race conditions that can corrupt the internal char array and cause ArrayIndexOutOfBoundsException, as demonstrated by a multithreaded test example.
This article explains that Spring Boot controllers are singleton by default, why that makes them unsafe when using non‑static fields, demonstrates the problem with sample code, and provides practical solutions such as using prototype scope or ThreadLocal variables.
This article explains why core Java collection classes such as ArrayList, HashSet, and HashMap are not thread‑safe, demonstrates the underlying mechanisms of their initialization and resizing, and presents multiple approaches—including Vector, synchronized wrappers, and CopyOnWrite variants—to achieve safe concurrent access.
This article explains the Singleton design pattern, presents five Java implementations (eager, lazy, synchronized, double‑checked locking, static inner‑class, and enum), compares their advantages and disadvantages, and provides multithreaded test code to demonstrate thread‑safety and resource usage.
This article explains Spring's bean scopes, compares singleton and prototype beans regarding thread safety, demonstrates the issue with shared state through code examples, and provides practical solutions such as using prototype scope or ThreadLocal to avoid concurrency problems.
Spring MVC controllers are singleton by default, which can cause thread‑unsafe behavior when using non‑static member variables; this article demonstrates the issue with example endpoints, shows how prototype scope resolves it, and outlines best practices such as avoiding stateful fields or using ThreadLocal.
A PLDI'20 study of open‑source Rust projects shows that while Rust’s safe code effectively prevents most memory errors, many bugs still stem from unsafe blocks, and even safe code can suffer thread‑safety issues, highlighting the need for better tooling and developer awareness.
This article explains why Spring MVC controllers are singleton by default, demonstrates the thread‑safety issues caused by shared instance variables, shows how to test the behavior with sample code, and presents solutions such as using prototype scope, avoiding member variables, or employing ThreadLocal.
A newly hired architect boasts high‑concurrency expertise but writes un‑commented Java code that misuses ConcurrentHashMap, leading to memory leaks; the ensuing investigation reveals missing equals/hashCode implementations, race conditions in a visit method, and a debate between synchronized blocks and putIfAbsent for safe updates.
The article explains why Spring MVC controllers are singleton by default, demonstrates the resulting thread‑unsafe behavior with example code, shows how applying @Scope("prototype") makes them prototype scoped, and provides best‑practice recommendations and a summary of Spring bean scopes.
This guide explains how to create a globally unique, auto‑incrementing variable in JMeter by using a synchronized Groovy script that leverages the built‑in props object, demonstrates setting an initial value, and compares locked versus unlocked execution results.
The article explains how to isolate and measure the time spent on request signature generation in an API performance test using micro‑benchmarks, provides Java and Groovy code examples, and discusses subtracting non‑request overhead to obtain calibrated throughput.
This article explains that Spring does not guarantee thread safety for its beans, describes the various bean scopes, clarifies why stateless singleton beans are safe, and shows how ThreadLocal works—including its implementation, usage, and potential memory‑leak pitfalls—so developers can write correct concurrent code.
This article explains the internal implementation of Java's StringBuilder and StringBuffer, demonstrates how concurrent appends cause incorrect lengths and occasional ArrayIndexOutOfBoundsException, and shows why StringBuffer remains thread‑safe by using synchronized methods.
The article explains how read‑modify‑write race conditions can occur when updating a ConcurrentHashMap from multiple threads, demonstrates a failing JUnit example, and shows how using the atomic compute method with a lambda expression eliminates the race and ensures thread‑safe updates.
This article explains the Java Singleton pattern, covering lazy (thread‑unsafe), eager, static inner‑class, enum, and double‑checked locking implementations, discusses their thread‑safety, performance, and serialization issues, and provides complete code examples for interview preparation.
This article explains why ConcurrentHashMap provides thread‑safe and high‑performance map operations, compares it with HashMap and Hashtable, and details the architectural changes from JDK 1.7’s segment‑lock design to JDK 1.8’s array‑list‑red‑black‑tree and CAS‑based implementation.
This article explains Java's ThreadLocal mechanism, shows how it provides thread‑confinement without synchronization, analyses its source code—including hash generation, internal ThreadLocalMap structure, set/get operations and resize logic—highlights potential memory‑leak pitfalls, and lists common application scenarios.
This article explains why Java's HashMap is inherently thread‑unsafe, detailing how JDK 1.7’s resize operation can create circular linked lists and data loss, while JDK 1.8’s insertion logic can cause overwrites, and provides code examples and step‑by‑step analysis.
This article explains Spring's five bean scopes, focusing on the differences between singleton and prototype beans, their performance advantages, thread-safety concerns, and why Spring chooses singleton as the default scope.
An in‑depth analysis of a long‑standing native crash on Android caused by thread‑unsafe initialization of GURL during CookieManager.getCookie calls, detailing stack traces, investigation steps, source code examination, and a lightweight application‑level synchronization fix that eliminated the issue in production.
This article explains why Java's HashMap is not thread‑safe, analyzing the dead‑loop and data‑loss problems caused by resizing in JDK 7 and the overwrite issue in JDK 8, with code examples and step‑by‑step thread interleaving illustrations.
This article explores how adding print statements, using Thread.sleep, and employing Integer objects affect thread safety in Java, illustrating why a non‑volatile flag can cause infinite loops, how synchronized I/O and sleep influence memory visibility, and why seemingly unrelated changes sometimes make the program terminate.
This article explains the Java Memory Model, describing how main memory and thread‑local working memory interact, the eight primitive actions defined by the JVM, the special semantics of volatile, long and double variables, and how these concepts underpin atomicity, visibility and the happens‑before principle in concurrent Java programs.
Through a series of Java demos, this article examines how storing non‑thread‑safe objects inside thread‑safe collections like ConcurrentHashMap or CopyOnWriteArrayList can still cause concurrency bugs, explains the underlying remove() implementation, and shows how switching to a thread‑safe Vector resolves the issue.
This article explains why traditional locking harms Java performance‑testing throughput, introduces lock‑free alternatives such as CAS and ThreadLocal, and provides a complete Java demo that shows how each thread can hold its own object to eliminate contention and boost speed.
This article explains how Java threads share objects, why immutable objects are safest, how to make mutable collections thread‑safe using synchronized wrappers or concurrent classes, handles non‑thread‑safe types like SimpleDateFormat, and demonstrates race‑condition fixes with synchronized blocks and AtomicInteger.
This article explains what ThreadLocal variables are, how they are implemented in Java using a per‑thread ThreadLocalMap, discusses potential memory‑leak pitfalls caused by weak keys, and demonstrates common usage scenarios such as per‑thread session storage and making non‑thread‑safe classes like SimpleDateFormat thread‑safe.
This article explains the semantics of Java's final keyword, how the compiler and JVM enforce immutability and memory‑barrier rules, and why final fields provide thread‑safe, write‑once‑read‑many behavior for both instance and static variables.
Although developers often overlook high‑concurrency scenarios, this article highlights two typical backend Java concurrency bugs—shared request state in singleton beans and improper lazy initialization—explains their pitfalls, and demonstrates correct thread‑safe patterns such as double‑checked locking and proper singleton design.
The article explains why using synchronized(this.getClass()) in anonymous test threads can produce empty mark records during performance testing, and shows how replacing it with a static synchronized save method resolves the thread‑safety issue.
This article explains why thread safety is essential in concurrent Java programs, introduces the lock concept, and provides detailed examples of using the synchronized keyword to protect code blocks, instance methods, static methods, and entire classes, including common pitfalls and inheritance rules.
This article provides a comprehensive overview of Java concurrency concepts, covering thread‑safety issues, variable visibility, atomic operations, the use of synchronized, volatile, ReentrantLock, ReadWriteLock, CountDownLatch, and other AQS‑based synchronizers, with code examples illustrating each mechanism.
This article explains how Spring bean scopes affect thread safety, why most beans are safe when stateless, how to use ThreadLocal correctly, its internal hash‑map design, and the memory‑leak pitfalls that arise when ThreadLocal entries are not cleaned up.
This article explains the thread‑safety problems of Java's HashMap in JDK 1.7 and JDK 1.8, showing how concurrent resize operations can create circular linked lists, cause infinite loops or data loss, and why the underlying implementation remains unsafe despite JDK 1.8's optimizations.
This article explains the hardware memory architecture, the role of caches, and how the Java Memory Model abstracts thread interaction with main and working memory, detailing the eight fundamental JMM operations, their ordering rules, and special considerations for long and double types to help developers write correct, high‑performance concurrent Java code.
This article explains why Java's SimpleDateFormat is not thread‑safe, demonstrates the resulting concurrency errors, and presents four practical solutions—including per‑call instantiation, ThreadLocal, Apache FastDateFormat, and Java 8's Instant with DateTimeFormatter—along with JMH benchmark results comparing their performance across JDK 8 and JDK 11.
This article explains how to perform load testing for scenarios where each row can be updated only once, using a thread‑safe queue to supply unique parameters to concurrent threads, and provides complete Java code examples for both a global queue and per‑thread queues.
This article explains four main categories of Java singleton implementations—eager (hungry), lazy (lazy), holder, and enum—detailing their basic forms, variations, thread‑safety characteristics, performance trade‑offs, and code examples, while also discussing pitfalls such as reflection and serialization.
This article explains thread safety problems, demonstrates how unsynchronized access to shared variables can produce incorrect results, and shows how Java's ThreadLocal and InheritableThreadLocal classes provide thread‑local storage to avoid concurrency bugs, including implementation details and usage examples.
This article explains the concept of Java String immutability, illustrates how references work with examples and diagrams, and discusses the benefits such as string pool reuse, hashcode caching, thread safety, and security that improve memory efficiency and application performance.
This article explains how the JVM allocates memory for Java objects, discusses the thread‑safety challenges of concurrent allocations, and describes the Thread‑Local Allocation Buffer (TLAB) mechanism and its impact on performance and garbage collection.
This article demonstrates how the non‑atomic i++ operation can cause race conditions in Java by using the vmlens tool to visualize thread interleavings, providing sample test code, Maven configuration, and an analysis of the resulting report.
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.
This article demonstrates how the non‑atomic i++ operation can cause race conditions in Java, using a simple multithreaded test and the vmlens tool to visualize the conflicting accesses and explain the underlying thread‑safety issue.
This article explains atomicity, thread safety, and thread‑unsafe behavior in Java, demonstrates a simple class with a volatile counter, runs two concurrent threads that increment it, shows the non‑atomic nature of i++, and analyzes why the final value may remain 1.
This article explains atomicity, thread safety, and race conditions in Java by walking through a concrete example where multiple threads increment a shared volatile variable, showing why the non‑atomic i++ operation leads to inconsistent results.
This article explains Java’s atomicity and thread‑safety concepts, demonstrates how a simple volatile counter increment isn’t atomic, and shows a multithreaded test that produces inconsistent results, illustrating why proper synchronization is required for safe concurrent access.
This article examines various Java singleton implementations—eager, lazy, double‑checked locking, static inner class, enum, and Kotlin object—analyzing their thread safety, reflection and serialization vulnerabilities, and shows how to harden them using volatile, constructor guards, and readResolve.
This article explains why thread safety concerns memory rather than threads, compares stack‑local and heap‑shared data, introduces ThreadLocal for per‑thread isolation, and covers mutual‑exclusion locks, optimistic CAS, and their appropriate use cases in concurrent programming.
This article explains why the classic Java SimpleDateFormat class is not thread‑safe, demonstrates the problems caused by using a static instance in concurrent code, and presents four practical solutions—including creating new instances, synchronizing, using ThreadLocal, and switching to the immutable DateTimeFormatter.
The article explains why thread safety concerns memory rather than threads, describes how local stack variables, ThreadLocal, locks, and CAS provide isolation and consistency in Java concurrency, and compares optimistic and pessimistic locking strategies with illustrative code examples.
This article analyzes data‑inconsistency problems caused by concurrent multithreaded updates in a CMDB system and presents a step‑by‑step exploration of synchronization solutions, ultimately implementing a robust Redis‑backed distributed lock in Python to guarantee atomic reads and writes while handling edge cases such as crashes and lock expiration.
This article explains why Java's SimpleDateFormat is not thread‑safe, demonstrates the problems caused by using a static instance in multithreaded code, and presents four practical solutions—including synchronized blocks, ThreadLocal, and the modern DateTimeFormatter—to ensure correct date handling.
This article explains the thread‑safe, ordered Java collection ConcurrentSkipListSet, compares it with TreeSet, describes its skip‑list based internal structure, lists its full API, and provides a multithreaded example demonstrating correct concurrent usage versus the failure of TreeSet.
