This article explains how ThreadPoolExecutor in JDK 1.8 recycles worker threads by analyzing the runWorker loop, the conditions under which getTask() returns null, and the different scenarios of thread termination with and without invoking shutdown(), illustrating the role of CAS and interrupt handling.
This comprehensive guide covers over forty operating system interview questions, explaining core concepts such as OS fundamentals, process and thread management, memory handling, file systems, I/O mechanisms, scheduling algorithms, and deadlock prevention, providing detailed answers and diagrams to help candidates excel in technical interviews.
The article details Go’s G‑M‑P scheduler, showing how lightweight Goroutines (G) run on OS threads (M) bound to virtual processors (P), describing runtime initialization, run‑queue management, work‑stealing, the main schedule loop, execution binding, and cleanup via goexit.
This article explains the concepts of processes and threads, their differences, interaction methods, the relationship between them, the three execution states of a task, the distinctions among parallel, concurrent, and serial execution, and the purpose and operation of process pools in operating systems.
This article explains the internal workings of Golang v1.0 coroutines, covering their creation, stack‑switching logic, scheduler design, virtual‑memory basics, assembly examples, channel handling, socket event loops, and the low‑level implementation of defer, panic, and recover.
This article explains the fundamentals of distributed locks, compares lock implementations based on asynchronous replication and Paxos protocols, and provides practical Redis and etcd/Zookeeper examples—including exclusive and shared lock mechanisms, code snippets, and usage considerations for reliability and safety.
Analyzing several major Go projects, the article catalogs frequent concurrency pitfalls—such as unbuffered channels, WaitGroup deadlocks, context leaks, loop‑variable races, double channel closes, timer errors, and RWMutex misuse—and offers concise, idiomatic fixes to prevent blocking, leaks, panics, and deadlocks.
This article provides two practical approaches, complete with theory, kernel tuning, source code links, and detailed step‑by‑step commands, enabling readers to set up and verify one million concurrent TCP connections on Linux systems.
This article explains the design and implementation of Java 8 Stream API, covering its composition, pipelining, internal iteration, parallel execution via ForkJoinPool, performance considerations, ordering semantics, and practical guidelines for using parallel streams effectively.
This article explains the concepts of eager versus lazy evaluation in Java, presents common scenarios for lazy initialization, demonstrates how to implement lazy loading with Supplier, virtual proxy, and delegate patterns, and shows practical Stream examples including infinite prime number generation.
This article explains the double-checked locking implementation of the Singleton pattern in Java, detailing why two null checks are necessary, the role of the volatile keyword in preventing instruction reordering and ensuring visibility across threads, and provides a complete example code.
After mastering the Socket protocol and a fixed‑QPS load‑testing model, I built a comprehensive Socket.IO performance test that simulates a teacher‑student scenario, measures message latency, identifies calculation errors and logging overhead, and reveals several bugs and optimization opportunities in the asynchronous handling and compensation threads.
This article explains the difference between eager and lazy evaluation, shows when and how to use lazy initialization in Java, demonstrates Supplier‑based lazy loading, virtual proxy patterns, and stream laziness with infinite streams and prime number generation, all with concrete code examples.
This article explains the fundamental concepts of processes and threads in operating systems, compares their characteristics, advantages, and disadvantages, and provides practical guidelines on when to use processes, threads, or a combination of both for concurrent execution.
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 demonstrates how to apply Java's ThreadLocal together with an AtomicInteger to generate unique minisource_id values for a collect‑and‑uncollect workflow, and shows the complete code modifications and performance‑test script used to measure request latency.
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 concept of thread pools, compares seven creation methods in Java, details their parameters, execution flow, and rejection policies, and provides practical code examples to help developers choose the most appropriate pool for reliable and efficient multithreaded programming.
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 walks through building a custom thread pool executor in Java, starting with a simple thread creation example, evolving through multiple design iterations, and culminating in a full-featured implementation that supports core and maximum pool sizes, task queues, thread factories, and rejection policies.
This article explores why JavaScript includes an event loop, explains its core mechanisms—including task and microtask queues—and compares how browsers and Node.js implement the loop, using code examples and diagrams to clarify the differences.
This article explains the limitations of volatile for compound updates, demonstrates non‑thread‑safe bank‑account examples, introduces synchronized locking, and then shows how AtomicReference with CAS operations provides a lock‑free, thread‑safe solution, including a deep dive into its internal implementation and related memory‑barrier concepts.
This article analyzes a microservice client’s connection‑timeout errors in a Kubernetes cluster, investigates Zookeeper‑based service discovery, uncovers one‑time watch semantics and a concurrency bug in rpcx’s channel handling, and presents a fix to ensure IP list updates.
This article explains how MySQL InnoDB generates AUTO_INCREMENT values, compares the full‑table locking mechanism before version 5.1 with the lightweight mutex introduced in 5.1, and describes the further improvements in 8.0 that rely on row‑based replication and lock‑mode settings.
This article provides an in-depth explanation of Java's AbstractQueuedSynchronizer (AQS) framework, covering its role in JUC concurrency utilities such as locks, semaphores, CountDownLatch, ReentrantReadWriteLock, and Condition, including template methods, state management, node structures, queue algorithms, and practical code examples.
This article provides a comprehensive overview of Java's HashMap and ConcurrentHashMap implementations, explains core concurrency concepts such as thread states, the differences between concurrency and parallelism, memory models, volatile semantics, singleton patterns, thread pools, ThreadLocal, CAS, and the AQS framework.
This article provides a detailed analysis of the Android HashMap implementation in SDK 28, covering its fields, internal Node class, constructors, resizing logic, hash function, collision handling, and related Map implementations, with complete source code excerpts and performance considerations.
The article thoroughly explains how CPU caches and the MESI coherence protocol interact with Java’s Memory Model, detailing the volatile keyword’s role in ensuring visibility and preventing instruction reordering, and illustrates these concepts with examples such as visibility problems and double‑checked locking.
This article clarifies that setting keepAliveTime to 0 in a Java ThreadPoolExecutor causes excess idle threads beyond corePoolSize to terminate immediately, correcting the common misconception that 0 means threads live forever, and demonstrates the behavior with a concise code example.
This article explains the true limits of concurrent TCP connections on a server, debunks common misconceptions about port numbers, details the TCP four‑tuple theory, outlines Linux file‑descriptor restrictions, shows how to tune kernel buffers with sysctl, and shares a real‑world test achieving one million active connections.
This article demystifies common misconceptions about server concurrency, explains the theoretical maximum TCP connections based on the four‑tuple, details Linux file‑descriptor and buffer limits, and walks through a practical experiment that achieves over one million simultaneous connections on a single machine.
This article explains how to use Java's CyclicBarrier and related concurrency utilities to parallelize user login preparation for load testing, reducing setup time and synchronizing multi‑stage performance tests with concrete code examples and sample console output.
This guide walks developers through a step‑by‑step progression of performance‑boosting techniques—including zero‑copy I/O, epoll, thread pools, lock‑free programming, IPC, RPC, database indexing, caching, Bloom filters, full‑text search, and load balancing—to help build faster, more scalable backend services.
This article explains how servers handle massive concurrent requests by evolving from simple multi‑process models to lightweight threads, then to event‑driven architectures with I/O multiplexing, highlighting the trade‑offs of blocking versus non‑blocking I/O and the role of coroutines.
This article explains why traditional locks fail under massive concurrent traffic, how distributed locks coordinate multiple servers to ensure correct total payouts, and compares Redis and Zookeeper implementations, highlighting their mechanisms, pitfalls, and practical considerations for large‑scale systems.
This article explains the concept of coroutines, compares them with ordinary functions, shows Python code examples of yielding and resuming execution, illustrates their historical background, and describes how they are implemented using heap‑allocated stack frames to achieve lightweight, user‑level concurrency.
Ruby 3.0, released as promised on Christmas, brings three‑times performance gains over Ruby 2, introduces MJIT, the experimental Ractor concurrency model, a static type system via RBS, a new Fiber Scheduler, and several syntax enhancements, with code examples illustrating these features.
This article introduces Java's CountDownLatch synchronization tool, explains its purpose as a gate or counter, demonstrates basic and advanced usage with code examples—including a simple counter and a student race scenario—and provides an in‑depth analysis of its underlying AQS‑based source code.
This article explains how distributed lock requirements arise when scaling from monolithic to multi‑server architectures, reviews the evolution of Redis‑based locking mechanisms from simple SETNX to Lua scripts and Redisson's advanced features, and provides detailed source‑code analysis of Redisson's lock, unlock, and lock acquisition implementations.
The article explains that System.currentTimeMillis()—a common Java API for timestamps—can become dramatically slower when called concurrently or very frequently, analyzes the native implementation causing the slowdown, and presents a cached‑clock solution to mitigate the performance issue.
This article explains the concept of thread pools, compares seven creation methods—including FixedThreadPool, CachedThreadPool, and ThreadPoolExecutor—covers their parameters, execution flow, and rejection policies, and offers guidance on selecting the most appropriate pool for Java applications.
This article explains how to adjust Linux kernel port ranges and file descriptor limits, explores the internal structures of TCP sockets, and walks through key kernel functions such as tcp_v4_rcv and __inet_lookup that locate sockets based on IP and port tuples, providing practical guidance for increasing TCP concurrency.
This article explains a real-world case where storing WeChat access tokens in a JSON file caused race conditions, analyzes the root cause, and demonstrates how to use PHP's flock() function with proper locking to safely read and write the token, including sample code.
This article explains Caffeine, a high‑performance Java local cache, covering its design improvements over Guava Cache, the W‑TinyLFU eviction algorithm, asynchronous read/write buffers, timer‑wheel expiration, and detailed source code analysis with examples.
This article explains the concept of Java thread pools, compares seven creation approaches, details their parameters, usage examples, rejection policies, and provides guidance on selecting the most appropriate pool implementation for robust multithreaded applications.
This comprehensive guide compiles 108 common Java multithreading interview questions, covering the purpose of concurrency, thread creation methods, lifecycle nuances, synchronization utilities, memory visibility, thread safety levels, debugging techniques, executor frameworks, concurrent collections, atomic operations, lock implementations, and best‑practice recommendations.
This article explains the concepts of task scheduling dependencies and workflow, introduces graph theory basics such as vertices, edges, and DAGs, and provides a complete Go implementation—including graph structures, BFS traversal, topological sorting, and concurrent execution—to efficiently manage dependent tasks in distributed systems.
This article explains why Java's Condition class should replace wait/notify for thread communication, demonstrates the thread‑livelock problem with notify, shows how Condition avoids it, compares performance with notifyAll, and provides complete code examples for producer‑consumer scenarios.
This article outlines a systematic approach to high‑performance, high‑concurrency backend development by examining CPU speed, cache and multithreading, memory hierarchy and paging, I/O optimization techniques, and the architectural patterns that tie these components together.
This article investigates the intermittent RejectedExecutionException caused by Executors.newSingleThreadExecutor, explains how Java's garbage collector and finalize method can prematurely shut down thread pools, demonstrates the behavior with reproducible code, and shows how newer JDK versions have fixed the issue.
This article explains the difference between synchronous and asynchronous Python, how each model handles concurrency, the two main async implementations (coroutine‑based and greenlet‑based), and when async can actually outperform sync in high‑load, I/O‑bound scenarios.
This article explains how to implement distributed locks using Redis, covering the essential requirements of mutual exclusion, deadlock avoidance, and fault tolerance, detailing single‑instance and multi‑instance algorithms, code examples with SETNX and Lua scripts, and discussing challenges such as latency, crashes, and persistence.
This article demystifies the true maximum number of concurrent TCP connections a single Linux server can sustain, explaining the theoretical limits of the TCP four‑tuple, the practical constraints imposed by file descriptor and memory settings, and walks through a real‑world experiment achieving one million connections.
This article explains the true limits of concurrent TCP connections on a server, debunks common misconceptions about port numbers and TCP four‑tuple space, and shows how Linux file‑descriptor and socket buffer settings affect real‑world scalability, illustrated with a million‑connection experiment.
This article provides a comprehensive source‑code walkthrough of Kotlin coroutines, explaining how launch creates a coroutine, how the compiler transforms suspend functions into state‑machine classes, and detailing the mechanisms of suspension and resumption through Continuation, Dispatchers, and the coroutine scheduler.
A flash‑sale of 100 bottles of a scarce product oversold due to an unsafe distributed‑lock implementation, leading to a P0 incident; the post analyzes the root causes, shows flawed Java/Redis code, and presents safer lock and inventory‑check solutions.
This article explains why multithreading improves program performance, distinguishes latency reduction from throughput increase, and provides practical formulas to determine the ideal number of threads for both I/O‑bound and CPU‑bound workloads, helping you fully utilize hardware resources.
This article explains the fundamentals of queues and blocking queues, describes how Java's java.util.concurrent.BlockingQueue works, outlines its main methods and common implementations, and provides a complete custom BlockingQueue source code example for multithreaded producer‑consumer scenarios.
The article explains Go's singleton pattern, detailing eager (init) and lazy implementations using sync.Mutex and sync.Once, provides full code examples, demonstrates that each accessor returns the same instance, and discusses trade‑offs between memory usage and performance.
This article provides a comprehensive analysis of Java's ConcurrentHashMap, covering its historical evolution, key internal fields, the thread‑safe put and remove operations, the complex resizing and transfer mechanisms, and auxiliary methods such as size, get, and clear, all illustrated with original source code.
This article explains MySQL's three lock levels—table, row, and page—describes next‑key, gap, and record locks, analyzes why deadlocks occur, and provides multiple real‑world examples and prevention strategies, including code snippets for reproducible scenarios.
This article examines the stock‑oversell problem in high‑concurrency e‑commerce systems, explains why native JVM locks fail in multi‑machine deployments, and compares practical distributed‑lock solutions using Redis (including RedLock and Redisson) and Zookeeper (with Curator), highlighting their advantages, drawbacks, and selection guidelines.
This article introduces the Actor model, its fundamental rules, and how it underpins Flink and Spark RPC mechanisms, then explains the Akka framework, its actor hierarchy, supervision, lifecycle, and dispatcher, providing a concise foundation for distributed big‑data processing.
This article explains why a non‑volatile boolean flag cannot reliably break a Java thread’s infinite loop, details the visibility and reordering issues that volatile solves, and presents correct solutions such as using volatile or AtomicBoolean for safe loop termination.
The article explains the stock‑oversell problem in a single‑machine e‑commerce system, shows why native Java locks fail in multi‑node deployments, and then details practical distributed‑lock solutions using Redis (including SET NX PX, Lua‑based release, RedLock algorithm and Redisson) and Zookeeper (ephemeral sequential nodes and Curator), before comparing their advantages, drawbacks, and offering selection guidance.
This article explains a practical fixed‑QPS load‑testing model for HTTP requests, provides reusable Java code for creating test tasks, and details two bug fixes—one for thread‑pool shutdown handling in asynchronous compensation threads and another for inaccurate request‑counting that caused over‑compensation.
This article explores the underlying principles of Java Virtual Machine garbage collection, detailing core concepts, classic algorithms, generational and incremental improvements, and the role of read/write barriers, helping developers grasp why mastering GC is a fundamental skill for high‑performance Java programming.
This article explains the true behavior of Thread.Sleep, how it interacts with operating system scheduling—both time‑slice and pre‑emptive models—and clarifies the differences between Sleep(milliseconds) and Sleep(0) for thread coordination.
This article presents various Java solutions for common interview multithreading problems that require sequential printing, demonstrating implementations using Lock, wait/notify, Condition, Semaphore, and LockSupport, along with detailed code examples and explanations of thread communication mechanisms.
This article explains how reactive programming, introduced by Microsoft in 2009 and adopted by Java through frameworks like RxJava and Spring Reactor, addresses high‑concurrency server‑side challenges, clarifies concepts such as backpressure, and compares Reactor with RxJava for modern backend engineers.
This article explains the internal state management, waiting queue, and node states of Java's AbstractQueuedSynchronizer (AQS), demonstrates how to create a custom reentrant lock by extending AQS, and walks through the lock acquisition and release process with detailed code examples.
This article explores the rise of reactive programming in Java, explains concurrency versus parallelism, demystifies backpressure, and compares the Reactor and RxJava frameworks, offering practical insights for modern high‑concurrency server development.
This article analyzes the internal workflow of Java's ThreadPoolExecutor, focusing on how worker threads are reclaimed under both normal RUNNING conditions and after shutdown, detailing the runWorker loop, getTask() null returns, and the role of CAS and interrupt handling.
This article explains how Java's ThreadPoolExecutor manages threads and tasks, covering the costs of thread creation, the roles of corePoolSize, workQueue, maximumPoolSize, rejection policies, keep‑alive time, and best practices for using bounded queues to avoid OOM.
This article examines the YYCache iOS library, covering its multi‑level architecture, LRU implementation, thread‑safe APIs, eviction policies, lock choices, disk‑storage strategies, Swift integration, performance benchmarks, and practical takeaways for building high‑performance mobile caches.
This article provides an in‑depth analysis of Java's ThreadPoolExecutor, explaining how Executors' factory methods create pools, detailing the constructor parameters, internal state management, task submission via execute, worker thread lifecycle, and the differences between shutdown and shutdownNow, with code excerpts for clarity.
This article explains the principles of Java's AbstractQueuedSynchronizer (AQS), compares semaphore and monitor mechanisms, analyzes the source code of ReentrantLock, and demonstrates how to create a custom non-reentrant mutex using AQS, with detailed diagrams and code examples.
The article investigates a CPU load spike caused by a red‑black tree cycle inside Java's HashMap after JDK 8, detailing monitoring steps, stack‑trace analysis, heap dump inspection, and concluding with a recommendation to replace HashMap with ConcurrentHashMap in concurrent scenarios.
This article provides a comprehensive analysis of the HotSpot JVM implementation of the synchronized keyword, covering object header layout, the three lock states (biased, lightweight, heavyweight), their acquisition and release processes, bytecode differences, and practical code examples to help readers understand Java concurrency internals.
This article explains the design and implementation of a Java‑based fixed QPS load‑testing framework, covering its multithreaded base class, concurrent executor, compensation thread, performance metrics collection, and provides source code links for practical use and further development.
This article reviews typical vulnerabilities in popular PHP frameworks—especially ThinkPHP—demonstrates how insecure update methods and multithreaded code can lead to SQL injection and race conditions, and shows how to mitigate them using pessimistic locks, transactions, and proper auditing steps.
This article explains how to enforce a specific execution order among three Java threads—first thread 1, then thread 2, and finally thread 3—using four techniques: the join method, CountDownLatch, a single‑thread executor, and CompletableFuture, each illustrated with complete code examples.
This article provides a comprehensive explanation of Java's HashMap and ConcurrentHashMap implementations, covering their internal data structures, hashing mechanisms, load factor, resizing process, collision handling, and the differences between JDK 1.7 and 1.8, along with practical interview questions and code examples.
This page provides a comprehensive collection of links to over a hundred interview‑focused articles covering Java, Spring, Redis, MySQL, concurrency, design patterns, and other backend development topics, organized by issue number for easy reference.
This article explains the different lock types—pessimistic, optimistic, and distributed—illustrates their use cases with code examples, compares four practical solutions for high‑concurrency deduction scenarios, and offers guidance on selecting the right locking strategy.
The article presents a design for an asynchronous component that is monitorable, fault‑tolerant, and integrates with zero overhead, compares Akka, RxJava, and a custom JUC‑based implementation, and selects the latter—using extended Callables and a CountDownLatch—to track business units, handle timeouts, and provide fallback behavior.
This article analyzes a real‑world incident where duplicate order IDs appeared under high concurrency, critiques the original Java implementation, demonstrates a concurrency test that exposed the flaw, and presents a revised, thread‑safe solution using AtomicInteger, Java 8 date‑time APIs, and IP‑based suffixes to guarantee uniqueness across multiple instances.
This article explains Go's channel primitive, comparing unbuffered and buffered channels, demonstrates how to avoid deadlocks with proper goroutine coordination, and shows typical patterns such as select, closing channels, and building concurrency controllers for robust backend services.
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.
The article analyzes a production incident where a Dubbo thread pool exhausted its threads due to CompletableFuture#join blocking, explains how the custom business thread pool caused mutual waiting, and presents a solution that isolates asynchronous tasks into a separate pool to restore service stability.
This article explains how Java's AtomicInteger and related atomic classes provide lock‑free thread‑safe operations to replace non‑atomic constructs like i++, detailing their inheritance, underlying Unsafe mechanisms, CAS implementation, memory barriers, optimistic locking, the ABA problem, and practical code examples for increment, decrement, and custom CAS‑based locks.
This article introduces the fundamentals of Java multithreading, explaining why concurrency is needed, the differences between programs, processes and threads, four ways to create threads, and common pitfalls such as thread safety and deadlocks, all with clear code examples.
This article explains Java thread pools, covering their purpose, advantages, core components, constructor parameters, built‑in pool types such as Cached, Fixed and Single thread pools, and the available rejection policies, providing code examples and practical guidance for efficient multithreaded programming.
This article provides an in‑depth overview of Java multithreading, covering fundamental concepts such as processes, threads, parallelism vs concurrency, thread creation methods, lifecycle states, synchronization mechanisms, memory model nuances, lock implementations, common pitfalls like deadlocks, and practical usage of thread pools with best‑practice recommendations.
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 Java's thread lifecycle, detailing its six states—New, Runnable, Blocked, Waiting, Timed_waiting, and Terminated—and describes eleven commonly used thread APIs such as join(), wait(), notify(), yield(), sleep(), currentThread(), getName(), getId(), getPriority(), setPriority() and stop().
This article explains how concurrency issues that appear in single‑threaded programs become amplified in distributed systems, covering consistency models, network reliability, clock synchronization, fault detection, backpressure, and cascading failures, and offers practical design and testing strategies to build resilient architectures.
This article examines the fundamental differences between traditional disk‑based DBMS and modern in‑memory databases, covering buffer management, lock versus latch mechanisms, logging and recovery, performance overhead, historical evolution, and architectural innovations that enable high‑performance memory‑resident data processing.
This article provides an in‑depth, illustrated overview of Java's Queue hierarchy, covering 18 concrete queue classes, their inheritance relationships, core methods, blocking and non‑blocking variants, practical usage examples, and code snippets to help developers master queue-based data structures and concurrency utilities.
