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.
This guide shows how to configure Nginx's limit_conn directives to restrict the number of simultaneous requests from a single IP, test the settings with ApacheBench, and verify that the limits effectively block excess traffic, helping mitigate CC attacks.
This article shares practical design principles for building scalable read services, covering stateless architecture, data closed‑loop processing, multi‑layer caching strategies, concurrency optimization, degradation switches, rate limiting, traffic switching, and other operational best practices.
This article explains how to build reliable distributed locks using Redis, introduces the official RedLock algorithm, discusses safety properties, compares it with simple failover approaches, and provides implementation details, performance considerations, and lock‑extension techniques.
This article presents a pattern‑based approach to performance optimization, describing common degradation anti‑patterns and corresponding optimization patterns—such as horizontal and vertical partitioning, runtime 3NF, data locality, and degradation—to help engineers improve response time, throughput, and availability in large‑scale backend services.
This guide explains key metrics, influencing factors, and practical tuning steps—including bandwidth, hardware, OS limits, TCP parameters, and server configurations—to assess and improve a backend system's maximum request handling capacity under high concurrency.
This guide explains two flash‑sale scenarios—single‑item seckill with a unique index and multi‑item seckill with quantity tracking—detailing table structures, SQL statements, concurrency handling, advantages, drawbacks, and an optimized version without locks, illustrated with step‑by‑step diagrams.
This article explains the backend architecture behind WeChat’s red‑packet feature, detailing how the system stores packet data, uses cache‑level atomic operations for grabbing, separates claim and settlement steps, and ensures high‑throughput, fault‑tolerant processing during peak usage.
This article explores the essential design considerations for building a short URL service, covering data structures, encoding algorithms, key length choices, capacity planning, sharding strategies, concurrency handling, network architecture, security measures, and a real‑world example.
This article explains why concurrent read‑write operations on a shared balance can cause inconsistencies, illustrates the problem with a purchase‑balance example, and shows how a Compare‑And‑Set (CAS) update clause guarantees atomicity and preserves data integrity.
The discussion explores various backend techniques—SQL conditional updates, scheduled tasks, cache flags, database and Redis locks, queues, and token‑based idempotency—to reliably manage e‑commerce inventory and avoid overselling under different traffic loads.
To improve page load speed while fetching additional data via AJAX, developers can choose between parallel and serial requests and handle concurrency using techniques such as sequential execution, callback counting, non‑blocking loops, or jQuery Deferred objects, each with its own trade‑offs.
Apache offers three core Multi-Processing Modules—prefork, worker, and event—each with distinct process/thread models, memory usage, and suitability for high-concurrency scenarios, and this article explains how they work, their trade-offs, and why event MPM is the most memory-efficient choice.
This article examines the key challenges of building large‑scale, high‑interaction web 2.0 platforms—including massive data processing, concurrency control, file storage, indexing, distributed architecture, AJAX usage, security, synchronization, clustering, and OpenAPI integration—offering practical considerations for robust backend design.
The article examines why PHP’s lack of native multithreading isn’t a fatal flaw for high‑concurrency servers when paired with Swoole, compares process‑based and thread‑based models, debunks performance myths, and highlights the productivity benefits of using PHP over C++.
When Node.js receives an asynchronous request, it packages the request into an object, delegates processing to a worker thread, enqueues the completed object, and then its event loop repeatedly pulls objects from the queue to invoke their callbacks, enabling non‑blocking I/O.
Although many claim PHP with Swoole is unsuitable for high‑concurrency servers compared to C++, this article explains how PHP’s process model, Swoole’s Table and Atomic features, and careful design can achieve comparable performance while offering faster development, and discusses the trade‑offs of multithreading versus multiprocessing.
The article details a backend architecture overhaul using Golang to address search inefficiencies, slow response times, and low conversion rates by introducing asynchronous data filtering, fast in‑memory computation, and performance‑tuned serialization and garbage‑collection strategies.
This article explains how to use Python's multiprocessing module to achieve true parallelism, covering Process creation, inter‑process synchronization primitives such as Lock, Semaphore, Event, communication tools like Queue and Pipe, and advanced patterns with Pool, all illustrated with runnable code examples.
PostgreSQL uses Multi-Version Concurrency Control (MVCC) to ensure reads never block writes and vice versa, assigning transaction IDs to rows, managing visibility with xmin/xmax, supporting isolation levels, and requiring periodic VACUUM to clean dead rows and handle XID wraparound.
This article explains what processes and threads are, how they relate, their key differences, and the advantages and disadvantages of each, helping readers grasp why multithreading can boost efficiency while processes offer stronger isolation and fault tolerance.
This article explains the Java volatile keyword, covering its definition, lightweight nature compared to synchronized, visibility guarantees, usage conditions, and practical patterns such as state flags, safe publication, volatile beans, and low‑cost read‑write lock strategies, illustrated with code examples.
This guide explains how to increase Linux's per-process file descriptor limits, adjust kernel TCP parameters, and adopt high-performance I/O models such as epoll or AIO to support tens of thousands of concurrent TCP connections.
The article summarizes Zhao Haiping’s 2015 QCon talk on how asynchronous processing, profiling, and dependency‑tree scheduling can dramatically improve performance and scalability of distributed backend systems, drawing lessons from Facebook’s migration to async PHP and Alibaba’s ongoing optimization efforts.
This article explains core performance testing concepts—including QPS, concurrency, response time, and throughput calculations—illustrates how to estimate system capacity, relate traffic metrics to daily PV, and outlines the perspectives of users, administrators, developers, and test engineers for evaluating software performance.
This article explains Netty's autoread switch, isWritable back‑pressure mechanism, and serialization strategies, showing how to control read/write rates, avoid thread‑pool overload, and reduce memory copies when handling TCP byte streams in high‑performance Java network applications.
This article analyzes the core principles and components of thread pools, explains why they are essential for performance and flow control, and compares the concrete implementations in JDK, Jetty 6, Jetty 8, and Tomcat, providing guidance for developers who wish to use or customize thread pools.
This article explains how to build a Java event‑notification system using the observer pattern, highlights typical mistakes such as concurrent modification and deadlocks, and presents several thread‑safe implementations ranging from synchronized blocks to CopyOnWriteArraySet and atomic primitives.
The article explains that asynchronous programming is essential for creating responsive user interfaces and highly scalable server applications by preventing long‑running operations from blocking UI threads or thread‑pool threads, and outlines the differences between CPU‑bound and I/O‑bound workloads.
This article explains the definitions of concurrent users (Vu) and transactions per second (TPS), provides practical methods for estimating these metrics in new and existing systems, and outlines how to calculate resource usage such as connection counts, memory, and file descriptors.
The article outlines practical principles for designing scalable software, covering reduced processing time, partitioning, concurrency, clear requirements, continuous testing, architecture‑first thinking, and a global view to ensure systems can handle more users, work, and data efficiently.
This article explains how to create and configure Guava LoadingCache instances, covering builder options, CacheLoader implementation, explicit insertion, callable loading, size‑based, timed, and reference‑based eviction, removal listeners, refresh strategies, statistics, asMap view, and interruption handling, with complete Java code examples.
This article explains what a deadlock is, why it occurs, the four necessary conditions that enable it, and outlines common strategies—including ignoring, detection and recovery, avoidance, and prevention—to manage or eliminate deadlocks in operating systems.
Java 8 introduced a suite of powerful enhancements—from default methods and the new Process API to StampedLock, improved concurrency utilities, Optional, flexible annotations, numeric overflow checks, enhanced file traversal, stronger SecureRandom, and Date.toInstant—each offering developers modern, efficient ways to write cleaner, safer code.
Using HTML5 instead of Flash, the article explains how to boost file‑upload speed by compressing or merging files before transfer, employing optimal concurrency levels, splitting files into chunks for fault‑tolerant, resumable and instant uploads, and choosing appropriate chunk sizes to balance overhead and performance.
