This article explains the inner workings of Java's synchronized methods and blocks, detailing the JVM method_info structure, relevant access flags, bytecode generation, monitorenter/monitorexit instructions, and the rules that ensure structured locking even during exceptions.
This article explains the Compare‑And‑Swap (CAS) primitive, its three operands, how Java's Unsafe class implements CAS methods, the internal workings of AtomicInteger, common pitfalls like spinning, single‑variable limits and the ABA problem, and the enhancements introduced in Java 8.
This article explains why multithreading and thread pools are essential for server‑side Java development, details the full ThreadPoolExecutor constructor parameters, and walks through the executor, addWorker, Worker, runWorker, and getTask implementations with illustrative diagrams.
This article explains how Java’s Unsafe class provides low‑level park and unpark methods, how the LockSupport utility wraps them for easier use, and demonstrates building a simple exclusive lock with AbstractQueuedSynchronizer, covering state handling, blocking mechanisms, and thread‑queue management.
This article explains multithreading fundamentals, covering thread concepts, lock mechanisms for database access, deadlock causes and solutions, recursive locks (RLock), data race issues, and daemon thread behavior. It also discusses connection pooling, timeout strategies to avoid deadlock, and practical code examples in Python.
This article explores five advanced Java thread techniques—custom thread names, priority management, ThreadLocal storage, user versus daemon threads, and processor affinity—showing how to apply them for better debugging, performance tuning, and reliable concurrent applications.
This article provides a comprehensive guide to common Java multithreading interview questions, covering thread ordering with join, lock vs synchronized, read‑write locks, wait vs sleep, blocking queues, producer‑consumer patterns, deadlock detection, thread dumps, thread states, and immutable objects, all illustrated with runnable code samples.
This article explains why a separate HttpRequestBase object is needed for each concurrent request in a performance testing framework, and provides a complete Java implementation of a FunRequest class that offers deep‑copy, cloning, and fluent configuration of GET/POST HTTP requests.
This article explores Go's panic/recover mechanism, identifies which runtime errors can be recovered, explains unrecoverable scenarios like thread exhaustion and map race, demonstrates best‑practice error handling with Go 1.13 features and popular error libraries, and offers concrete logging strategies for robust server development.
This article explains Python coroutine fundamentals, async/await syntax, and demonstrates how to use aiohttp with an event loop and semaphore to dramatically speed up I/O‑bound network requests, providing practical code and performance results.
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.
This comprehensive guide explains Java thread pool fundamentals, creation methods, core parameters, rejection policies, execution flow, common work queues, and shutdown techniques, while providing interview questions, source‑code analysis, and practical code examples for robust concurrent programming.
This article explains the various ways to terminate a running Java thread—including using exit flags, the deprecated stop() method, interrupt(), and exception handling—illustrates each approach with code samples, compares Thread.interrupted() and isInterrupted(), and discusses the dangers of forceful termination and lock release.
This article explains the internal architecture of Java's ThreadLocal, including its ThreadLocalMap implementation, the purpose of the special hash code 0x61c88647, collision handling strategies, proper usage patterns in web applications, and precautions for avoiding memory leaks in thread pools.
This article outlines the essential design points for a local Java cache—including data structures, size limits, eviction policies, expiration handling, thread safety, blocking mechanisms, simple APIs, and persistence options—while providing concrete code examples and implementation guidance.
This article explains what Go channels are, how they are implemented in the runtime, their data structures, creation, sending, receiving, closing semantics, common pitfalls, and includes detailed code examples to illustrate channel behavior in concurrent programs.
This article walks through building a basic round‑robin load balancer in Go, covering the underlying principles, data structures, reverse‑proxy integration, atomic indexing, concurrency handling, health‑check mechanisms, and how to extend the implementation for production use.
A comprehensive guide that explains Python concurrency concepts—including processes, threads, synchronization primitives, thread pools, asyncio, greenlet, and gevent—while showing how to choose the right model for CPU‑bound or I/O‑bound tasks.
This article explains the Java volatile keyword, covering its memory visibility and ordering guarantees, how it interacts with the Java Memory Model, common pitfalls such as lack of atomicity, and practical usage examples like flag signaling and double‑checked locking in concurrent programming.
The article explains Java’s AbstractQueuedSynchronizer as the foundation of many concurrency utilities, details how ReentrantLock leverages AQS’s FIFO CLH queue, state field, and lock acquisition/release mechanisms, compares it with synchronized, and demonstrates building a custom lock with AQS.
This article uses a vivid fruit‑store analogy to explain Java multithreading concepts such as locks, synchronized blocks, wait/notify, thread states, time‑slicing, and volatile variables, helping readers grasp core concurrency mechanisms in an engaging narrative.
This article explains why improper use of ThreadLocal can lead to memory leaks in Java, details the underlying weak‑reference mechanism, and provides practical steps—including explicit removal and Spring integration—to safely manage ThreadLocal data and avoid resource exhaustion.
This article explains why HashMap is unsafe in multithreaded environments, how ConcurrentHashMap uses segmented locks and immutable entries to achieve high concurrency, and details its internal data structures, core operations, and performance considerations with illustrative Java code examples.
This article explains the definition of thread pools, the pitfalls of using Executors factory methods, details the ThreadPoolExecutor constructor parameters, compares different Executors implementations, demonstrates OOM tests, and offers guidelines for configuring thread pool parameters and rejection policies.
This article compiles essential Java backend interview topics, covering the differences between TreeSet and HashSet, HashMap collision handling and resizing, ConcurrentHashMap's lock strategy, thread pool creation, synchronization primitives like CountDownLatch and CyclicBarrier, database indexing, CAP theorem, idempotence, locking mechanisms, JVM GC roots, reflection, dynamic proxies, distributed locks, ThreadLocal optimization, and key considerations for designing a high‑traffic seckill system.
This article explains Go's map internals, covering the hmap and bmap structures, hash table design, bucket layout, initialization, lookup, insertion, deletion, resizing mechanisms, concurrency considerations, and provides extensive code excerpts to illustrate each step.
This article explains the Java Memory Model, how hardware and the JVM handle memory, the eight JMM operations, instruction reordering, memory barriers, and the specific memory semantics of volatile and final variables, providing code examples and visual diagrams for clarity.
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 subtle difference between concurrency and parallelism using a ground‑hog and cart analogy, shows how task decomposition creates concurrent pipelines, and maps the model to scalable web‑service architecture, referencing Rob Pike’s talk “Concurrency is not Parallelism”.
This article walks through creating a lightweight TCP port scanner in Go, covering basic TCP handshake theory, single‑port testing, looping over ports, adding concurrency with WaitGroup, implementing timeouts, using the flag package for command‑line options, and handling race conditions with a mutex.
This article explains the Java RUNNABLE thread state, how it differs from traditional OS ready and running states, the impact of time‑slicing and I/O blocking, and demonstrates with code that even blocked I/O operations keep a Java thread in the RUNNABLE state.
This article uses a factory analogy to demystify operating‑system concepts such as processes, threads, mutual‑exclusion locks, and semaphores, illustrating how CPUs, workspaces, workers, and access controls interact to enable concurrent execution while preventing conflicts.
This article explains the Redis concurrent key competition problem, illustrates typical scenarios where multiple clients modify the same key, and presents four practical solutions—optimistic locking with WATCH/EXEC, distributed locks, timestamp ordering, and message‑queue serialization—to ensure data correctness under high concurrency.
This article breaks down the Java Memory Model, detailing how atomicity, visibility, and ordering work in multithreaded programs, illustrating the impact of instruction reordering, and showing how synchronized, volatile, and happens‑before rules ensure correct concurrent behavior.
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 naive synchronized locks can cause deadlocks in Java, introduces the four Coffman conditions, and presents three practical solutions—acquiring all resources at once, using explicit locks with wait/notify, and ordering lock acquisition—to prevent deadlock in concurrent applications.
This article explains how Alibaba’s Wisp2 brings Go‑like coroutine performance to Java by replacing OS thread scheduling, details its design, shows benchmark improvements over traditional thread‑pool models, compares it with Project Loom, and provides practical code snippets for enabling Wisp2 in production.
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.
The article presents a practical approach for load‑testing API endpoints that modify a database field with a small set of possible values, using per‑thread counters and modulo arithmetic to avoid duplicate parameters, and includes a complete Java demo implementation.
This article explains the concepts of processes and threads in Python, compares multi‑process, multi‑thread, and combined approaches, shows how to use fork, the multiprocessing module, process pools, subprocesses, and inter‑process communication with queues, and provides complete code examples with results.
This article dissects Netty's custom FastThreadLocal and FastThreadLocalThread implementations, showing how they replace JDK ThreadLocal with constant‑time indexed access, padding to avoid false sharing, and customizable initialization and cleanup to boost backend concurrency performance.
This article explains why Redis is chosen for projects—highlighting its performance and concurrency benefits, detailing its data types, expiration and eviction policies, and offering solutions to common issues such as cache consistency, avalanche, penetration, and key‑competition.
This article explains how Kotlin coroutines work in Android, comparing launch and async, detailing the role of suspend functions, thread switching with Dispatchers, and how the coroutine framework handles suspension and resumption to simplify asynchronous programming.
This article explains how using a lock that protects only a single resource can lead to incorrect behavior when multiple related resources are involved, demonstrates the problem with Java synchronized methods, and shows how a class‑level lock resolves the issue.
This article explains three Java thread‑creation techniques—extending the Thread class, implementing the Runnable interface, and implementing the Callable interface—provides complete code examples for each, compares their advantages and disadvantages, and recommends the best practice for concurrent programming.
Go achieves high concurrency by using its own M‑P‑G scheduling model, where lightweight goroutines (G) run on logical processors (P) that are mapped onto kernel threads (M), allowing user‑space scheduling that avoids the overhead of OS thread context switches.
This article explains Go's garbage collection mechanism, describing its Mark‑Sweep model, the three collection phases, latency implications, and practical tips for reducing pause times through memory‑pressure reduction and runtime debugging tools.
This article provides a comprehensive overview and source‑code dissection of Java's ArrayList, covering its inheritance hierarchy, fields, constructors, addition, removal, modification, traversal, serialization, sorting, array conversion, thread‑safety considerations, and practical usage tips.
This article explains how java.util.concurrent.atomic.LongAdder provides a more efficient counting mechanism than AtomicLong under high contention, discusses its trade‑offs in space and precision, presents JMH benchmark results, and walks through the internal implementation details such as cells, CAS loops, and hash‑based distribution.
This article explains a rare MyBatis exception caused by a concurrency issue in OGNL expression evaluation, shows the stack trace, reproduces the bug with multithreaded test code, analyzes the root cause in method accessibility, and notes that upgrading to Ognl 2.7 or MyBatis 3.3.0 resolves the problem.
This article explains the challenges of deadlock detection in Linux kernel lockdep, especially with read‑write locks, and presents a formally proven general deadlock prediction algorithm that models lock dependencies using a two‑thread abstraction, lemmas, and lock‑type promotion to reliably predict potential deadlocks.
After uncovering an unprotected API that allowed unlimited resource access, the author created a rough Java program that uses a fixed-size thread pool and CountDownLatch to fetch 100 000 items in parallel, retrieving 10 000 records per thread via HTTP GET requests.
This article explains the fundamentals of Multi-Version Concurrency Control (MVCC), compares its implementation in PostgreSQL and InnoDB, and highlights key differences in version storage, transaction handling, vacuuming, and index updates.
Explore how concurrency can be broken down into three essential problems—division of work, synchronization/coordination, and mutual exclusion—using real‑world analogies and Java examples, and learn practical strategies like appropriate task sizing, thread communication, and locking mechanisms to write efficient, safe multithreaded code.
This article explores eight Java concurrency techniques—including join, main‑thread join, wait/notify, thread pools, Condition, CountDownLatch, CyclicBarrier, and Semaphore—to achieve sequential thread execution, complete with code examples and sample outputs for each method.
This article compiles essential Java interview questions covering language fundamentals, core APIs, collections, concurrency mechanisms, JVM internals, design patterns, database concepts, and Netty networking, providing a thorough reference for candidates preparing for backend development positions.
This article examines the Jenkins doCheckJobName implementation, explains how it validates job names and permissions, and explores the underlying Java technologies such as ViewGroup, CopyOnWriteArrayList, CopyOnWriteMap, TreeMap, and concurrency mechanisms used in Jenkins' source code.
This article explains how Python handles concurrency by comparing processes and threads, describing the Global Interpreter Lock, and detailing the threading, thread, and queue modules along with their synchronization primitives and practical usage patterns.
System.currentTimeMillis() appears fast but under heavy concurrent calls it becomes dramatically slower due to kernel‑mode time‑of‑day queries, and this article explains the root cause, shows benchmark results, and offers a cached‑timestamp solution to restore performance.
The paper reverse‑engineers Linux’s Lockdep and introduces a universal deadlock prediction algorithm that treats mutexes as write‑locks of read‑write locks, using a two‑thread model and indirect‑dependency analysis to accurately detect potential deadlocks in complex rwlock scenarios.
This article explains the architecture of Node.js, the limitations of its single‑threaded event loop for CPU‑heavy workloads, and how the experimental worker_threads module provides a multi‑threaded solution, including core concepts, APIs, best practices, and sample code to improve performance.
This article shares a practical experience of implementing a Redis‑based distributed lock, explains the lock acquisition and release processes, discusses common pitfalls such as expiration handling and concurrency bugs, and provides Q&A on design choices, high‑availability, and future improvements.
This article explains how Java 8 Parallel Stream uses the common ForkJoinPool, why it may not improve performance for large proxy‑IP validation tasks, and demonstrates a custom ForkJoinPool solution that dramatically reduces execution time.
This article explains the concept of a “double‑spend” bug encountered during a coin‑exchange API, describes a multithreaded testing approach in Java to reproduce the issue, analyzes the root cause of non‑atomic balance checks, and provides sample code illustrating the detection and prevention method.
This article compiles ten of the most challenging Java interview questions, covering topics such as wait/notify placement, lack of multiple inheritance, operator overloading, string immutability, password storage, double‑checked locking singleton, deadlock creation and resolution, serialization pitfalls, and static method overriding, with detailed explanations and code examples.
This article compiles a comprehensive set of Ant Financial interview questions covering Java fundamentals, concurrency, Spring, Linux, database design, NoSQL, distributed systems, and personal experience topics across the first, second, and third interview rounds.
This article explores the design and implementation of a Redis‑based distributed lock used since 2013, analyzes lock acquisition and release mechanisms, discusses common pitfalls such as expiration handling and race conditions, and presents possible improvements like Lua scripts and Redisson.
This article explains the purpose and classification of database locks, demonstrates how to manually apply and inspect table and row locks in MySQL, analyzes lock‑related status variables, and offers practical optimization strategies to improve concurrency and performance.
This article explains the purpose and usage scenarios of Java's ThreadLocal, details its two main functions for storing thread context and ensuring thread safety, discusses garbage‑collection nuances, presents sample code with results, and outlines essential best‑practice guidelines for safe multithreaded development.
Over the past decade, Erlang has evolved from a niche functional language into a robust platform with powerful concurrency, fault tolerance, and a rich ecosystem, illustrated by its key applications, knowledge ladder, recent improvements, and future prospects for both Erlang and its Elixir community.
The article describes a Java performance testing framework that was refactored from a request‑based to a method‑based design, introducing a ThreadBase class and specialized adapters for HTTP requests, database queries, and concurrent execution, and discusses the advantages of code‑based concurrency and Groovy.
This article lists the comprehensive set of technical and design questions asked in the first, second, and third interview rounds for Alibaba Tmall, covering topics such as JVM garbage collection, concurrency utilities, Redis caching, distributed system design, and performance optimization.
This article explains a practical approach to performance‑testing Dubbo add and delete methods of a message queue by pre‑generating payloads, using a thread‑safe LinkedBlockingQueue, and driving the calls with JMeter‑compatible Java code.
This article presents a Groovy‑based modular framework for automating complex, interrelated API tests, detailing how to structure test modules, manage user credentials and tokens, and execute concurrent requests using custom thread handling, with full source code examples for the main driver, UserCenter, and base classes.
The article introduces a Java performance testing framework that shifts from request‑centric to method‑centric design, provides a reusable ThreadBase class, and demonstrates concrete implementations for HTTP requests, database queries, and a concurrent executor to collect timing metrics, while also discussing the merits of coding versus tooling and Groovy advantages.
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.
This article explains atomicity, thread safety, and race conditions in Java by showing how a volatile counter increment can produce nondeterministic results when accessed concurrently, complete with sample code and console output analysis.
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 describes how to conduct load testing of Dubbo queue service methods for adding and deleting messages using Java concurrency utilities and JMeter, including code examples for constructing test data, managing a thread‑safe LinkedBlockingQueue, and handling initialization challenges during repeated test runs.
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 MySQL's lock types—including table and row locks, InnoDB's shared, exclusive, and intention locks—covers lock algorithms such as record, gap, next‑key, and insert‑intention locks, discusses deadlock and blocking issues, and details transaction management, isolation levels, and related configuration parameters.
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 introduces Java multithreading fundamentals, covering four thread creation techniques, the five-stage thread lifecycle, communication methods, thread‑pool usage, common synchronization locks, and the main concurrent container classes for building high‑performance backend applications.
This article explains why multithreading is needed, outlines the challenges of concurrent access, and provides a detailed overview of four Java thread lock mechanisms—synchronized, ReentrantLock, Semaphore, and AtomicInteger—along with their characteristics, usage patterns, and performance considerations.
Over two months, I interviewed with multiple companies for Java backend roles, sharing detailed experiences from technical rounds—covering JVM, concurrency, distributed locks, databases, and system design—to highlight key questions, effective answers, and practical advice for succeeding in similar backend development interviews.
The latest Java Development Handbook introduces 21 new coding rules, revises over a hundred guidelines, and adds clearer examples on lock handling, switch‑null checks, floating‑point comparisons, collection conversions, and guard statements, while inviting developers to download the free PDF and join a live discussion.
The newly released Java Development Handbook introduces three major upgrades—21 new coding rules, over a hundred revisions, and richer examples—while offering practical guidance on lock handling, switch NPE avoidance, floating‑point comparisons, guard statements, and other common Java pitfalls, all available for free download.
This article presents five Java code snippets—covering floating‑point comparison, wrapper equality, switch handling of null, BigDecimal construction, and lock usage—and challenges readers to identify the correct outcomes, exposing common misconceptions and best‑practice solutions.
This article explains how iOS developers can improve multithreaded performance by understanding the readers‑writers problem, using GCD barrier APIs or pthread_rwlock_t, and applying proper lock granularity and recursive locks to achieve safe and efficient concurrent reads and writes.
This article introduces Java multithreading by explaining the relationship between processes and threads, the benefits of concurrency, common pitfalls like race conditions, and how to safely manage shared variables using ThreadPoolExecutor, AtomicInteger, volatile, and CAS operations.
This article explains RxJava2's backpressure mechanisms, compares the five Flowable strategies (MISSING, ERROR, BUFFER, DROP, LATEST), demonstrates their behavior with practical experiments, and shows how to use Subscription and FlowableEmitter to build a demand‑driven, memory‑safe data pipeline.
The maximum number of Java Virtual Machine threads depends on CPU, operating system, JVM version, memory allocation, and configuration, with practical limits ranging from a few thousand on modest hardware to over ten thousand on high‑end systems, as demonstrated by several real‑world experiments.
This article explains how traditional per‑connection thread handling (blocking I/O) wastes resources, then demonstrates Java NIO multiplexing and AIO callbacks with complete code examples, showing how they reduce thread usage and eliminate blocking while processing many simultaneous socket connections.
The article walks through Go’s 1.9.2 scheduler on Linux, explaining how the three abstractions—G (goroutine), M (OS thread), and P (processor)—are created, bound, and used in the scheduling loop to run, yield, and balance goroutines via local, global, and stolen queues.
Early Lock Release (ELR) is an optimization that moves lock release before log flushing to improve concurrency, and this article explains its principle, MySQL server‑ and InnoDB‑level implementations, potential side effects such as dirty reads and cascade rollbacks, and its measured performance impact.
This article explores Go's goroutine implementation by dissecting the M‑P‑G model, scheduling strategies, preemption mechanisms, and low‑level context‑switch details, complemented with code snippets and assembly examples to illustrate how lightweight user‑level threads achieve high concurrency.
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 guide walks you through the complete process of planning, scripting, locally testing, and scaling a load test to over 50,000 concurrent users using JMeter and BlazeMeter, covering script creation, sandbox configuration, engine sizing, cluster setup, and master‑slave orchestration.
This article introduces C# multithreading concepts, demonstrates thread creation, memory isolation, data sharing, thread safety with locks, and explains the use of Join and Sleep methods, providing practical code examples and best‑practice guidance for concurrent programming.
