This article provides a comprehensive overview of Java's ThreadPoolExecutor, detailing its constructors, internal state management, task execution flow, worker thread lifecycle, queue strategies, rejection policies, and practical usage examples, while also offering guidance on configuring pool sizes for different workloads.
A comprehensive collection of Java interview questions covering fundamentals, common collections, concurrency, JVM internals, design patterns, data structures, networking, databases, caching, messaging, frameworks, distributed systems, and micro‑service architecture to help developers prepare for junior to mid‑level positions.
This article explains how the Disruptor framework achieves ultra‑low latency and high throughput in Java by using a ring‑buffer based producer/consumer model, detailing its architecture, sequencing algorithm, wait strategies, and practical code examples for both publishing and processing events.
This article examines common MySQL concurrency problems—including table locks from MyISAM, metadata locks during online DDL, row‑level deadlocks, and lock‑wait timeouts—explains how to detect them with processlist and InnoDB status, and provides practical mitigation strategies.
This article examines typical MySQL concurrency problems—including table lock‑induced slow queries, metadata lock blocking during online schema changes, deadlock scenarios, and lock‑wait timeouts—provides step‑by‑step reproductions, analysis of lock behavior, and practical mitigation strategies such as using InnoDB, online DDL tools, and monitoring techniques.
This article explains why distributed locks are needed in Java applications, outlines the essential conditions they must satisfy, and compares three practical implementations—database‑based, Redis‑based, and Zookeeper‑based—providing code snippets and performance considerations for each.
This article explains how to correctly implement a Redis-based distributed lock in Java, covering essential reliability requirements, step‑by‑step code for acquiring and releasing locks, and detailed analyses of common flawed approaches, ensuring atomicity and proper ownership handling.
This article explains how Java's synchronized(this) keyword creates an object lock that allows only one thread to execute a synchronized block at a time, demonstrates various scenarios with code examples, and shows how non‑synchronized sections remain concurrent while all synchronized sections on the same object are blocked.
This article explains the Java volatile keyword, covering its memory‑model semantics, how it guarantees visibility and ordering, why it does not provide atomicity, and demonstrates typical usage patterns such as flag signaling and double‑checked locking for singletons.
This article explains how Java's synchronized keyword works internally, covering its implementation via monitorenter/monitorexit, the role of object headers and monitors, and the various lock optimizations introduced in JDK 1.6 such as spin locks, biased locks, lightweight locks, lock elimination, and lock coarsening.
The article explores the history, design challenges, and performance impact of Python's Global Interpreter Lock (GIL), explaining why it persists, how it limits multithreaded execution, and what recent changes and research reveal about possible alternatives.
This article provides a clear, step‑by‑step explanation of database transactions, covering the ACID properties, how atomicity, consistency, isolation, and durability are implemented, and introduces MVCC as a modern concurrency control technique with practical examples and diagrams.
This article explains how Percona Server 5.7 implements a thread‑pool model for MySQL, detailing the activation parameters, internal architecture, functional threads, timer mechanisms, and several performance optimizations such as priority scheduling and special handling for long‑running commands.
This article explains Python's inter-process communication methods, including process creation, queues, pipes, locks, and pools, and introduces coroutines as lightweight alternatives, detailing their creation with gevent, practical web crawling, and socket server implementations, highlighting performance benefits and appropriate use cases.
This guide compiles a comprehensive list of Java interview topics covering fundamentals, object‑oriented features, collections, concurrency, web technologies, databases, Spring framework, ORM tools, Linux, Redis, and project management, providing a solid study roadmap for backend developers.
This article explains various iOS thread synchronization tools—including NSLock, NSRecursiveLock, NSConditionLock, NSCondition, @synchronized, dispatch_semaphore, pthread_mutex, and the deprecated OSSpinLock—detailing their internal implementations, usage patterns, code examples, and performance considerations for developers seeking safe concurrent programming on Apple platforms.
This article analyzes a real Alibaba internal financial‑system incident where a one‑cent accounting error arose from concurrent database writes after a distributed‑lock timeout, details the root‑cause investigation, and presents two remediation strategies—adjusting timeout settings and strengthening idempotent controls—to prevent similar issues.
A tiny 0.01‑yuan discrepancy in an Alibaba product revealed duplicate settlement records, exposing a distributed‑lock timeout and concurrency issue that led to double commits, and the article walks through the root‑cause analysis, reverse engineering of the process, and two remediation strategies focusing on timeout adjustments and idempotency controls.
This article provides a comprehensive overview of Java concurrency, covering thread creation methods, thread pools, thread models, the Future and Fork/Join frameworks, volatile and CAS mechanisms, AQS, synchronized locks, and various concurrent queue implementations, with practical code examples and references for deeper study.
This article provides a high‑level summary of Java concurrency, covering thread creation methods, thread models, thread pools, Future and CompletableFuture, the Fork/Join framework, volatile, CAS, AQS, synchronized locks, and concurrent queue implementations, with code examples and reference links for deeper study.
This article delves into Go's channel mechanism, explaining its three core signal properties—delivery guarantee, state, and data presence—while providing clear code examples for unbuffered, buffered, and context‑based channels to help developers write reliable concurrent programs.
This article explains Java’s asynchronous call mechanisms, reviews thread counters like CountDownLatch, introduces the Future pattern with its core roles and structure, provides a step‑by‑step code implementation, and shows how the JDK implements Future using Callable and FutureTask.
This article explains the concepts of synchronous and asynchronous execution, common concurrency problems such as dirty reads and non‑repeatable reads, and presents practical solutions using Java synchronized blocks, database pessimistic and optimistic locks, Hibernate lock modes, and performance‑optimizing techniques for high‑traffic web applications.
This article explains the Java Condition interface, its relationship with ReentrantLock and AQS, demonstrates usage examples, and delves into the internal waiting queue and signaling mechanisms that enable advanced thread coordination beyond basic synchronized monitors.
This article explains the structure, features, and internal workings of Java's ReentrantReadWriteLock, compares it with ReentrantLock and synchronized, provides usage examples, analyzes state management with bitwise operations, and covers lock acquisition, release, downgrade, and the role of LockSupport.
This article explains how lock-free techniques such as Compare-And-Swap (CAS) and Java's atomic classes—including AtomicBoolean, AtomicInteger, AtomicReference, and their array and field updaters—provide optimistic concurrency control, reduce context switches, and improve performance compared to traditional locking mechanisms.
This article explains why lock optimization matters in high‑concurrency Java applications and presents practical techniques such as reducing lock hold time, shrinking lock granularity, using read‑write locks, lock splitting, lock coarsening, and lock elimination to improve performance.
This article explores Java’s Lock interface and its underlying implementation, detailing the role of AbstractQueuedSynchronizer (AQS) in building ReentrantLock, the internal class hierarchy, synchronization mechanisms, and provides a step‑by‑step guide to creating a custom lock using AQS.
This article explains essential Java concurrency concepts—including synchronous vs. asynchronous execution, concurrency vs. parallelism, critical sections, blocking and non‑blocking operations—covers thread states, creation methods, priorities, common thread APIs, and the Java Memory Model’s guarantees on atomicity, visibility, and ordering.
This article examines common Java singleton implementations—including eager, thread‑safe lazy, double‑checked locking, and static inner‑class approaches—explaining their requirements, potential memory‑leak pitfalls such as ThreadLocal‑induced OOM, and how improper usage in multithreaded environments can lead to unexpected instance creation and performance issues.
This article explains key Java concurrency concepts—including synchronization, parallelism, critical sections, blocking vs non‑blocking, thread lifecycle, priority, common thread methods, interrupt handling, and the Java Memory Model’s guarantees of atomicity, visibility, ordering, and happens‑before relations—providing practical examples and code snippets for backend developers.
This article explains how Java ThreadLocal works internally, details its core methods and internal classes, analyzes the relationship between Thread, ThreadLocalMap, and WeakReference, and discusses memory‑reclamation strategies and potential OOM issues when used with thread pools.
This article presents a complete design and implementation of a flash‑sale (SecKill) system, detailing entity models, DAO methods, service and controller layers, a high‑concurrency test, and an improved solution using row‑level locking to prevent overselling under heavy load.
Learn how Java thread pools work, why uncontrolled thread creation harms performance, and how to use the JDK Executor framework—including key methods, common configurations, and pitfalls like silent errors with submit—to build efficient, scalable concurrent applications.
This article explains how CountDownLatch and CyclicBarrier work in Java, illustrates their usage with practical Dragon‑Ball analogies, compares their features, and provides code snippets and real‑time system scenarios to help developers synchronize threads effectively.
This article explains the concept of deadlocks, outlines the four necessary conditions, and demonstrates a step‑by‑step Linux workflow using pstack and gdb together with a sample pthread program to identify, analyze, and fix cross‑locking deadlock scenarios.
This article explains Java’s ReentrantReadWriteLock, detailing its shared read lock and exclusive write lock behavior, comparing it to ReentrantLock and concurrent collections, and provides clear code examples demonstrating read‑read sharing, write‑write exclusion, and read‑write mutual exclusion.
This article explains how Java's Lock interface and its ReentrantLock implementation provide flexible thread synchronization, inter‑thread communication via Condition objects, and the distinction between fair and non‑fair locking, complemented by illustrative code screenshots.
This article introduces Java's wait/notify thread communication mechanism, explains its principles with analogies, details the behavior of wait and notify methods, provides step‑by‑step code examples—including a simple producer‑consumer queue—and highlights important considerations such as lock handling and thread states.
The article explores Python’s Global Interpreter Lock (GIL), explaining its origins, how it limits true multithreading, the challenges of removing it, historical attempts, recent improvements, and why developers often prefer multiprocessing over threading for parallel execution.
This article explains the purpose of Java's ThreadLocal class, shows a practical example with code and output images, compares it to synchronized locking, and demonstrates how ThreadLocal provides each thread with an independent variable copy for safe concurrent access.
This article explains Java’s synchronized keyword’s reentrant lock capability, demonstrates how nested synchronized methods acquire the same lock without deadlock, explores additional features such as automatic lock release on exceptions, using arbitrary objects as monitors, and illustrates the double‑checked locking pattern for singleton implementation.
The article answers twelve Java concurrency questions, covering Meituan’s simple Akka use, when to prefer ReentrantLock or synchronized, queue rejection policies, Java 8 ConcurrentHashMap internals, ThreadPoolExecutor workflow, read‑write locks and Conditions, interview preparation, beginner resources, volatile ordering nuances, and notes on unclear flash‑sale overselling safeguards.
This guide explains Storm's architecture, the roles of spouts and bolts, the hierarchy of nodes, workers, executors, and tasks, and shows how to configure concurrency by adding workers, adjusting executor and task counts, and handling special cases for optimal stream processing performance.
This article compiles a Java club’s Q&A covering backend development essentials—from network bandwidth checks and static‑method hooking to JNI choices, OSGi modularity, plugin performance, CPU‑heavy thread analysis, ConcurrentHashMap improvements, micro‑service frameworks, cross‑data-center protocols, JVM GC mechanisms, inheritance alternatives, ThreadLocal pitfalls, career advice, cloning, generics erasure, JVM tuning, multithreading strategies, lock upgrades, monitoring tools, database failure handling, Spring Data JPA design, and distributed transaction practices.
This article explains the limitations of Java's synchronized keyword, introduces the Lock framework from java.util.concurrent.locks, compares their features, and demonstrates practical usage through multiple code examples covering ReentrantLock, tryLock, lockInterruptibly, ReadWriteLock, and fairness concepts.
This article explains how unsynchronized access to instance variables can cause dirty reads in multithreaded Java programs, demonstrates the issue with sample code, shows how adding the synchronized keyword resolves it, and explores the behavior when multiple objects each hold their own lock.
This article explains Java's synchronized keyword, demonstrating how synchronized methods and blocks control thread execution order, prevent dirty reads, and illustrate the differences between synchronized and non‑synchronized code through multiple runnable examples.
This article explains how to design and implement a Java‑based flash‑sale (seckill) system that can handle tens of thousands of concurrent requests, covering entity modeling, DAO methods, service logic, controller handling, a concurrency simulation test, and an improved locking strategy to prevent overselling.
This article explains how Node.js achieves its single‑threaded, non‑blocking behavior through callbacks, an event‑driven model, and an event‑loop that leverages libuv’s thread pool, and it illustrates these concepts with detailed code examples and diagrams.
The article examines the upgrade to a balance‑based financial accounting system, defines hotspot accounts, explains why they pose concurrency challenges, and evaluates several technical solutions—including optimistic locking, asynchronous processing, and account splitting—to guide appropriate strategy selection for different business scenarios.
This article explains MySQL's transaction fundamentals, the ACID properties, common concurrency problems such as dirty reads, non‑repeatable reads and phantom reads, and demonstrates each isolation level with step‑by‑step command‑line examples and recommendations for real‑world applications.
This article explains the thundering herd phenomenon in Linux network programming, demonstrates how to reproduce it with multi‑process accept and epoll examples, analyzes why modern kernels often suppress it, and discusses mitigation techniques such as mutex locking in Nginx.
This article explains how to design performance testing scenarios, covering test models, metrics, script preparation, concurrency calculations, pressure strategies, run times, delay settings, user termination, monitoring methods, and various typical scenario types such as baseline, load, mixed, capacity, large‑concurrency, stability and scalability tests.
This article explains the architecture and Java code for a high‑concurrency flash‑sale system, covering request distribution, pre‑processing, queue selection, transaction handling, and database interaction to efficiently manage limited‑stock purchases under massive traffic.
This article chronicles Toutiao’s evolution from a monolithic Python/C++/PHP stack to a large‑scale Go‑based microservice architecture, detailing the reasons for adopting Go, the design of the kite framework, concurrency models, timeout control, performance tuning, monitoring, and a reusable DAO component for efficient RPC aggregation.
This article explains how Oracle uses various lock types—including DML, DDL, and internal locks—to protect shared resources, details the lock manager workflow, describes the three lock components and lock modes, and shows practical SQL examples of transaction handling and blocking detection.
This article reviews Python threading fundamentals—including mutex locks and condition variables—explains their interaction, compares threading.Lock with threading.RLock, and presents a concise implementation of a thread‑safe task queue with illustrative diagrams and test code.
This article explores the challenges of mutual exclusion and idempotency in distributed environments, explains the underlying principles of locks in multi‑threaded and multi‑process contexts, and presents practical implementations using Zookeeper, Redis, Tair, and the Cerberus and GTIS frameworks to ensure reliable, scalable operations.
The article presents a Java program where 100 threads each increment a volatile int 1,000 times, showing that the final value may be less than the expected 100,000, and explains that volatile only guarantees visibility, not atomicity, making it unsuitable for concurrent modifications.
This article introduces the java.util.concurrent package introduced since JDK 5, explains the five thread‑pool creation methods, demonstrates how to use Runnable and Callable, details BlockingQueue operations and implementations, and summarizes best practices for building robust, high‑concurrency Java applications.
This article shares Qunar's practical experiences with message-driven architecture, detailing consumer handling of duplicate messages, ordering, concurrency control, asynchronous processing, and batch strategies, and presents concrete solutions such as idempotent checks, deduplication tables, versioning, and QMQ's built‑in executors.
This article describes how a Java‑based HTTP service was transformed from a synchronous, thread‑blocking design to a fully asynchronous architecture by evaluating coroutine, Actor model, and Rx approaches, and ultimately implementing a Graph‑Based Execution Engine integrated with Servlet 3.0 and Spring MVC to improve stability, performance, and throughput.
ScyllaDB, a Cassandra‑compatible NoSQL database, achieves over tenfold performance improvements through a thread‑per‑core design, asynchronous I/O, custom caching, self‑tuning schedulers, a user‑space TCP/IP stack, and LLVM‑JIT query execution, making it a compelling study for high‑performance database engineering.
This article explains the internal workings of Java's Object.wait() and notify() methods, detailing how synchronized blocks, monitorenter/monitorexit instructions, the HotSpot ObjectMonitor, wait sets, and entry lists cooperate to manage thread coordination and lock ownership in multithreaded environments.
The Disruptor library provides a lock‑free, CAS‑driven ring‑buffer queue that eliminates lock contention and false sharing, delivering 4–7× higher throughput and nanosecond‑level latency compared to Java’s built‑in queues, and is employed by systems such as Log4j 2, Apache Storm, and Meituan‑Dianping.
This article explains key performance testing concepts such as system throughput, QPS/TPS, concurrency, response time, and their interrelationships, provides practical calculation examples, shows how daily PV relates to TPS for different platforms, and outlines essential metrics and formulas for evaluating software performance.
The article explains why distributed systems are fundamental for handling massive web traffic, detailing concepts such as high throughput, concurrency, low latency, load balancing, layered architectures, concurrency models, caching, NoSQL storage, fault tolerance, scaling, deployment, and monitoring, while highlighting practical techniques and challenges.
An objective comparison of Go, Java, and C/C++ (including C++98 and C++11) examines concurrency, performance, syntax, type systems, initialization, error handling, ecosystem, tooling, and industry adoption, offering practical insights for language selection without bias.
This article examines MySQL InnoDB's next‑key lock behavior by creating a test table, running concurrent transactions, and analyzing how the lock range is determined across primary and secondary index columns, revealing why certain insert statements are blocked while others succeed.
A developer recounts how a seemingly trivial MySQL UPDATE statement—‘UPDATE table_name SET sum = sum + 5 WHERE id = 1’—proved thread‑safe for aggregating file counts across a multi‑threaded module, highlighting the importance of knowledge reserves and cautious evaluation before implementing complex synchronization solutions.
This article explains the design principles of Linux kernel RCU, details the implementation of rcu_read_lock, describes how interrupt handlers update shared data safely, and clarifies when old pointers can be reclaimed using call_rcu or synchronize_rcu.
A seemingly safe configuration swap using barriers caused a crash because a shallow copy duplicated resource pointers, leading to premature freeing of the active configuration; the article explains the bug, shows the faulty code, and presents a corrected approach.
This article explains how traditional ACID transactions fall short for modern large‑scale systems and presents lock‑free transaction methods, atomic and partial cache‑switch techniques, and a PostgreSQL‑style MVCC model for key‑value databases, including practical rules and trade‑offs.
Distributed locks prevent concurrent conflicts over shared resources in distributed systems, and this article explains ZooKeeper’s approach using ordered sequential nodes, illustrating the lock acquisition and release process with command-line examples and a complete Java implementation.
This article explains how WeChat's iOS client tackled SQLite performance bottlenecks by introducing multi‑handle threading, enabling WAL mode, redesigning the Busy‑Retry mechanism, and applying I/O enhancements such as preserving WAL size and mmap usage, resulting in over 90% reduction in perceived lag.
This article provides a comprehensive overview of SQL Server transaction concepts, ACID properties, lock types and escalation, blocking analysis using system DMVs, isolation level configurations, and deadlock detection and resolution, illustrated with practical code examples and diagrams.
The article analyzes write‑mostly, read‑light cache scenarios such as driver location updates and counter increments, discusses lock bottlenecks, proposes horizontal sharding and per‑record locking, explores lock‑free approaches with data‑integrity signatures, and summarizes practical optimization techniques for high‑concurrency back‑end systems.
This article explains the principles of RPC, evaluates performance‑critical factors such as I/O models and transport protocols, and provides a step‑by‑step guide to building a high‑throughput, Netty‑based RPC server in Java, including design, code structure, testing, and possible enhancements.
This article explains Java’s HashMap internals, compares JDK 1.7 and 1.8 implementations, details the bucket array, linked‑list‑to‑red‑black‑tree conversion, resizing logic, performance gains of up to 100 % in 1.8, and warns against using HashMap in concurrent contexts.
The article explains how to design a producer‑consumer model using Java's BlockingQueue, customize ThreadPoolExecutor's rejection policies—especially replacing the default AbortPolicy with a blocking strategy via a custom RejectedExecutionHandler—to safely handle full queues and improve concurrency control.
This article explains the differences between Ruby threads and processes, when to use each for performance gains, illustrates practical scenarios, and provides code examples for simple multithreading, multiprocessing, and using the Parallel gem.
The article explains MySQL high‑watermark throttling, a technique that limits concurrent updates on hot rows to protect database performance during extreme flash‑sale traffic, and demonstrates its effectiveness with real‑world Alibaba Cloud RDS metrics.
This article explains how atomic operations, Java concurrency primitives, database transaction mechanisms, and scalability techniques combine to ensure data consistency and high performance in large‑scale e‑commerce systems under extreme traffic loads.
This article provides a detailed explanation of various Java lock mechanisms—including fair and unfair locks, spin locks, lock elimination, lock coarsening, reentrant, class and object locks, biased, lightweight, heavyweight, pessimistic and optimistic locks—as well as practical code examples and a lock state table to help developers understand concurrency control in the JVM.
This article examines various techniques for proactively refreshing Memcached entries before they expire, including dual‑key schemes, timestamp‑based checks, and lock‑based updates, and presents a preferred Java implementation that minimizes cache‑stampede and reduces memory overhead.
This article analyzes a puzzling MySQL deadlock scenario where concurrent DELETE statements on a uniquely indexed row lead to a deadlock, explaining the lock modes, InnoDB's deadlock‑prevention strategy, and the conditions that make such deadlocks possible.
This article explains the ACID fundamentals, common concurrency anomalies such as dirty, non‑repeatable and phantom reads, the four SQL‑standard isolation levels, how MySQL implements them, and step‑by‑step command‑line tests demonstrating their effects on real transactions.
This article explains the purpose of Python’s Global Interpreter Lock, how it limits multithreaded performance on multi‑core CPUs, distinguishes CPU‑bound versus I/O‑bound scenarios, and shows why multiprocessing is usually the preferred solution for parallel execution.
The article explains how concurrent transactions can cause deadlocks when resources are locked, and introduces the Actor model—combining data, behavior, and message passing—to give data its own active logic, thereby naturally handling concurrency and avoiding such deadlocks.
A metaphorical story follows a newly created thread as it learns about extracting request parameters, performing login, handling CPU scheduling, using caches, encountering deadlocks, and ultimately witnessing a system reboot, illustrating core concepts of multithreading, concurrency control, and thread‑pool lifecycle.
This article shares practical lessons and common pitfalls encountered while developing numerous Go‑based microservices for Teamwork Desk, covering topics such as framework choices, panic handling, request body reuse, SQL handling, pointer usage, naked returns, variable shadowing, concurrent map access, and vendoring best practices.
This article explains the evolution of concurrent I/O in PHP—from traditional multi‑process and multi‑thread blocking models, through the leader‑follower pattern and I/O multiplexing with epoll, to modern asynchronous programming using the Reactor model, coroutines, and the high‑performance Swoole extension.
This article explores two practical approaches to implementing a delayed queue—using a sorted‑queue with JDK's DelayQueue logic and a Redis‑based solution with ordered sets and Spring Scheduled—to handle high‑throughput order processing while discussing their trade‑offs and implementation details.
The article explains how InnoDB’s auto‑increment handling changed after MySQL 5.1.22—from using a table lock to a lightweight mutex for predictable‑row inserts—and details the three innodb_autoinc_lock_mode settings, their impact on concurrency and replication, and related pitfalls such as non‑sequential IDs.
This article explores the fundamentals of concurrency versus parallelism, the challenges of writing correct concurrent programs, the evolution from OS threads to green threads, Goroutine scheduling, actor‑model concepts, and modern strategies such as thread pools, async callbacks, and Rust's ownership model.
This article provides an extensive overview of Java concurrency, covering synchronous vs asynchronous calls, critical sections, blocking and non‑blocking behavior, deadlock, starvation, livelock, concurrency levels, the Java Memory Model, atomicity, visibility, ordering, thread lifecycle, synchronization mechanisms, thread pools, and related utilities.
This article analyzes the unique complexities of China's 12306 train ticketing system, proposes a domain‑driven aggregate model centered on train trips, explains seat‑allocation rules and overlapping interval handling, and outlines a CQRS and event‑sourcing architecture to achieve strong consistency and high concurrency.
This article explains the concept of rate limiting to protect system stability, outlines when to apply it during high‑traffic events, and provides a concise Java implementation using Semaphore, including code snippets for acquiring, processing, and releasing permits.
This article provides a comprehensive overview of InnoDB's transaction lock mechanisms, covering row‑level lock types, table‑level locks, lock management procedures, deadlock detection, and practical examples, all based on MySQL 5.7.10.
