This article analyzes a real‑world overselling incident caused by an unsafe Redis distributed lock in a high‑traffic flash‑sale service, explains the root causes, and presents safer lock implementations, atomic stock checks, and architectural improvements to prevent similar failures.
A senior architect’s over‑confident, un‑commented Java code using ConcurrentHashMap triggered a severe memory leak, revealing pitfalls in hashCode/equals implementation, non‑atomic map updates, and the trade‑offs between synchronized blocks and putIfAbsent for high‑concurrency monitoring.
This article examines seven key reasons why deploying databases in Docker containers is problematic, covering data safety, performance bottlenecks, networking complexities, statefulness, resource isolation, cloud platform constraints, and hardware requirements, while also suggesting cautious strategies for selective containerization.
This article evaluates popular Java microservice frameworks—Spring Boot, Micronaut, Quarkus, and Helidon MP—by measuring their ease of development, compilation time, startup latency, memory usage, and high‑load request handling, using identical CRUD applications deployed on Docker and GraalVM.
This article explains MySQL index structures—including B‑Tree, B+Tree, and hash indexes—their underlying principles, performance characteristics, and practical usage guidelines such as left‑most prefix, full‑text indexing, and common pitfalls, providing a comprehensive guide for database developers.
Angular, a Google‑maintained front‑end framework from version 2 onward, offers cross‑platform capabilities such as progressive web apps, native mobile and desktop applications, along with high performance through code generation, server‑side rendering, automatic code splitting, and a rich productivity ecosystem including CLI, IDE support, testing, animation and accessibility tools.
This article explains how the WebSocket API provides bidirectional, message‑oriented communication, compares its latency and overhead with XHR and SSE, discusses compression and custom protocols, and offers practical deployment and tuning guidelines for long‑lived connections.
This article provides a step‑by‑step methodology for diagnosing and resolving common online failures in Java services, covering CPU bottlenecks, disk I/O problems, memory leaks, garbage‑collection inefficiencies, and network anomalies such as timeouts, TCP queue overflows, and RST packets.
This article explains Linux's zero‑copy techniques—mmap, sendfile, and splice—detailing how they reduce data copies between user and kernel space, improve I/O efficiency, handle edge cases like SIGBUS, and leverage DMA to minimize CPU overhead in server file transfers.
The article explains that using SELECT 1 with LIMIT 1 instead of COUNT(*) to test whether rows exist can dramatically improve query performance, shows the typical COUNT(*) approach in SQL and Java, and provides a streamlined alternative with code examples and practical benefits.
This article explains the zero‑copy technique in Java, covering basic I/O concepts, buffer management, mmap + write and Sendfile methods, and how frameworks like NIO, Netty, Kafka, and RocketMQ use these mechanisms to eliminate data copies and improve performance.
Node.js’s single‑threaded model relies on an asynchronous continuation framework, and this article explains the core concepts—execution frames, continuations, link points, ready points—and how async_hooks, AsyncLocalStorage, and related APIs can be used to trace, debug, and ensure clean async task handling in backend applications.
This article reviews the most frequently asked Java collection framework interview questions, covering differences between ArrayList, LinkedList, Vector, ArrayDeque, HashSet, HashMap, Hashtable, and the distinction between Collection and Collections, while explaining underlying implementations and performance considerations.
This article explains the differences between normal and unique indexes in MySQL, examines how they affect query and update performance, details InnoDB's change‑buffer mechanism, and provides practical guidance on when to prefer ordinary indexes for better write efficiency.
This article details the redesign of the 58 APP Android home page (version 9.0), covering overall UI and data module architecture, component design inspired by fragments, handling of search bar animations, fling behavior, performance optimizations, and lessons learned from the development process.
This article explains how to achieve high‑performance bulk inserts in .NET Core applications by converting entities to CSV or DataTable formats and using MySQL's LOAD DATA and SQL Server's SqlBulkCopy, providing reusable extension methods, interface abstractions, and performance benchmarks.
This article details a real‑world test that loads 200 million rows into a MySQL TokuDB table in under six minutes, achieving roughly 570 k writes per second, and compares the results with InnoDB while providing configuration tips and bulk‑loader considerations.
This article explains the differences between Java's HashMap and TreeMap, covering their underlying implementations, performance characteristics, thread safety, and how to customize TreeMap for descending order, helping developers choose the right map for their needs.
This article explains how to load over 20 billion rows into MySQL using the XeLabs‑compiled TokuDB engine, detailing configuration tweaks, table schema, bulk‑loader commands, benchmark results that reach 574 k rows per second, and practical tips for handling auto‑increment keys.
This article walks through common Linux memory inspection commands, explains the meaning of the buff/cache field, and then dives into MySQL join types, join algorithms, buffer settings, and performance‑tuning tips, all presented as a simulated interview with promotional side notes.
This article examines why full‑table scans on massive MySQL tables are slow, explains standard LIMIT‑based pagination, and presents several optimization strategies—including sub‑queries, ID‑range filtering, and temporary tables—backed by concrete performance measurements.
This article presents a concise Big O cheat sheet that aggregates the time‑complexity notations for common data structures, sorting algorithms, graph and heap operations, and visualizes performance curves, helping readers quickly recall best‑, worst‑, and average‑case scenarios.
This article explains Redis's custom Simple Dynamic String (SDS) implementation, its dynamic expansion mechanism, and the performance benefits such as O(1) length retrieval, buffer overflow avoidance, and efficient memory allocation strategies for high‑throughput applications.
This comprehensive guide walks you through Chrome DevTools panels—including Console, Elements, Network, Sources, Performance, Lighthouse, Security, and advanced commands—detailing shortcuts, core methods, debugging techniques, performance metrics, and practical tips for front‑end developers to optimize and troubleshoot web applications.
This article introduces Google’s Protocol Buffers (ProtoBuf), explains its principles, shows how to install the compiler, provides a complete Java example for defining, compiling, and using .proto files, and compares its encoding speed and memory usage against JSON, highlighting ProtoBuf’s advantages.
This guide explains how to systematically analyze Linux performance problems—including CPU, memory, disk I/O, network, and load—using 5W2H methodology, built‑in monitoring commands, perf, flame‑graph visualizations, and a real‑world Nginx case study to pinpoint and resolve bottlenecks.
This article explains common MySQL performance problems such as missing indexes and lack of pagination, and provides practical guidance on data size limits, concurrency settings, query time targets, table design, index types, and a variety of SQL optimizations with concrete code examples.
This article explains various MySQL pagination methods—including simple LIMIT queries, sub‑query optimizations, ID‑range filtering, and temporary‑table approaches—provides detailed performance measurements on a large order_history table, and concludes with practical recommendations while also promoting a comprehensive interview‑question PDF collection.
This article analyzes the performance bottlenecks of React Native applications, explains the framework's working principles, and presents practical optimization strategies such as bundle splitting, JS bytecode, data synchronization via an information center, and native‑driven list components to improve rendering speed and responsiveness.
This article compares the three I/O multiplexing mechanisms—select, poll, and epoll—by analyzing their time complexities, limitations, trigger modes, performance characteristics, and implementation details, helping developers choose the most suitable method for different Linux networking scenarios.
This article explains Java's Integer caching mechanism, why using == on Integer objects can give unexpected results outside the -128 to 127 range, how the Integer.valueOf method and the IntegerCache work, and how to inspect the behavior with javap and JVM options.
The article describes how to build a high‑performance waterfall‑flow ListView in Flutter by extending SliverMultiBoxAdaptor, managing child reuse, lazy loading, edge‑based insertion, garbage collection, and paint‑only updates, achieving a modest FPS boost on Xianyu’s search page while outlining remaining challenges such as scroll‑to, memory use, and lifecycle callbacks.
This article explains how Spring Boot uses Tomcat by default, shows how to replace it with Undertow, and presents benchmark results that demonstrate Undertow's superior throughput and lower memory consumption for high‑concurrency Java web applications.
This article explains Caffeine's high‑performance local cache features, presents JMH benchmark results that show it beating Guava, ConcurrentMap and ehcache, details its expiration, refresh and eviction mechanisms, compares memory usage and eviction algorithms, and provides migration code for Guava users.
This article explains why massive TIME_WAIT TCP connections appear under high concurrency, the impact on services, and practical methods—such as adjusting socket reuse and reducing TIME_WAIT duration—to prevent new connection failures.
Browser caching works by storing copies of web resources in memory, disk, or service‑worker caches and using HTTP headers such as Cache‑Control, Expires, ETag, and Last‑Modified to decide freshness, allowing strong (local) and negotiated (weak) cache stages, while developers can fine‑tune performance with CDN settings, IndexedDB, Service Workers, and HTML5 storage to create optimal, auditable cache strategies.
The article explains why using SELECT 1 with LIMIT 1 to test for record existence is more efficient than counting rows with SELECT count(*), and shows how to rewrite both SQL and Java code for better performance.
This article explains the principles of zero‑copy I/O, covering buffer concepts, virtual memory, mmap + write and sendfile methods, and demonstrates Java implementations using MappedByteBuffer, DirectByteBuffer, channel‑to‑channel transfers, as well as Netty’s CompositeChannelBuffer for efficient data handling.
Learn how to verify the ngx_http_stub_status_module compilation, configure Nginx stub_status endpoint, create Bash monitoring scripts, set up Zabbix user parameters, and build templates, triggers, and graphs to monitor Nginx performance metrics such as active connections, requests, and waiting clients.
This article compares two popular formulas for estimating Java thread pool size, analyzes their equivalence, and provides practical guidelines for configuring thread counts in I/O‑bound and CPU‑bound workloads, including code examples and performance considerations.
This article explains how to replace Spring Boot's default embedded Tomcat with Undertow, compares their architectures, presents benchmark results showing Undertow's superior throughput and lower memory usage, and concludes that Undertow is the better choice for high‑concurrency Java web applications.
The article explains why using COUNT(*) to test record existence is inefficient and demonstrates an optimized approach that replaces COUNT(*) with SELECT 1 LIMIT 1 in SQL and a corresponding null‑check in Java, improving database performance especially when many rows match the condition.
The article explains how decompiled Java bytecode often reveals a new StringBuilder being created on each loop iteration, leading to unnecessary memory consumption, and shows how to replace implicit concatenation with explicit StringBuilder.append calls, chain them properly, and eliminate dead StringBuilder code.
Under high‑traffic conditions, servers can generate massive numbers of TCP TIME_WAIT sockets, consuming local ports and causing “address already in use” errors; this article explains the underlying causes, impact on services, and practical mitigation strategies such as keep‑alive headers and socket reuse.
The article describes how the WeChat Pay client was rebuilt using a C++‑based cross‑platform framework to unify iOS and Android implementations, improve code reuse, reduce bugs, and achieve measurable performance and productivity improvements while introducing a UseCase‑driven architecture, routing mechanism, and disciplined network request handling.
The article details a step‑by‑step investigation of a Spring Boot application that unexpectedly used 7 GB of physical memory despite a 4 GB heap limit, revealing how native memory allocations, the Inflater class, and glibc memory pools caused off‑heap leaks and how proper configuration and library updates resolved the issue.
This article explains MySQL’s internal workflow, covering the Server layer components, Storage Engine layer, connection handling, query cache behavior, lexical and syntax parsing, optimization decisions, and execution steps, including tips for long‑connection management and common pitfalls.
This article examines the limitations of traditional Kubernetes Service implementations, introduces Tencent TKE’s IPVS‑BPF mode that bypasses nf_conntrack using eBPF for SNAT, details its design and implementation steps, and presents extensive performance measurements showing significant latency and throughput improvements.
This article explains how HiveCube can replace traditional development for multi‑dimensional aggregation in a data‑warehouse, covering background, theory of cube, with‑cube/rollup/grouping‑sets syntax, grouping_id handling, practical implementation tips, performance tuning, and a comparison with conventional methods.
This article describes how the Qunar hotel search team reduced Lucene stored‑fields deserialization overhead and GC pressure by implementing a custom Codec that caches stored fields in memory, redesigning the storage format, and evaluating the performance and space benefits of the approach.
This article explains how browser refresh rates affect React rendering, breaks down the tasks performed in a single frame, and introduces the Fiber architecture that enables interruptible, incremental updates for smoother user experiences.
The article explains why creating unlimited Goroutines in Go can exhaust system resources, demonstrates the problem with a sample program, and presents practical methods—including channel throttling, sync.WaitGroup, and third‑party Goroutine pools—to safely limit concurrency and improve performance.
This article explains how to use RocketMQ for traffic‑shaping in a Spring Boot application, covering its core components, consumer pull configuration, integration via rocketmq‑spring‑boot‑starter, a practical like‑praise use case, a Maven setup, YAML configuration, and advanced topics such as dynamic scaling and batch consumption.
This article outlines how Alibaba's Taobao front‑end team built a comprehensive engineering, architecture, and platform ecosystem—including Rax, ICE, PWA, and custom interactive tools—to ensure the 2020 618 e‑commerce promotion ran smoothly and delivered high performance, scalability, and innovative user experiences.
This article explores the rapid rise of AI in the frontend ecosystem, compares native and web‑based inference solutions, evaluates frameworks such as TensorFlow JS, ONNX JS, WebNN and the new MNN.js, and shares performance data, code examples, and future directions for cross‑platform AI deployment.
This article presents a Python-based method for quickly profiling dozens of large database tables by generating and executing column‑wise SQL queries, avoiding full table reads, and exporting the results to an Excel file for easy analysis.
The article recounts a production OOM incident triggered by a misconfigured HttpClient evictExpiredConnections setting that caused uncontrolled thread growth, explains the underlying keep‑alive TCP behavior and NoHttpResponseException, and presents the corrective measures of using a singleton HttpClient and proper connection‑pool monitoring.
This article presents a comprehensive overview of JDK8's garbage collection mechanisms, detailing memory regions, available collectors, key tuning parameters, thread settings, and practical commands, complemented by eight illustrative diagrams and a downloadable PDF cheat sheet for quick reference.
The article outlines Android’s cold‑start sequence, describing how the system’s zygote, system_server services, and Activity Manager Service allocate resources, fork a new process, create the Application and Activity objects, render the first UI frame, and replace the placeholder window, helping developers diagnose and optimize launch performance.
This article explains what database indexes are, their advantages and disadvantages, when to create or avoid them, various index types, and practical SQL optimization techniques, including code examples for efficient pagination in MySQL.
This article explores how to implement Dark Mode in WeChat public platform articles, covering detection methods, challenges of custom inline styles, comparative algorithms from Chrome and Outlook, a custom color‑processing solution, and performance optimizations for first‑screen rendering.
This article curates and explains several of StackOverflow’s most popular Java questions—covering branch prediction, password handling, exception handling, deterministic random strings, historic timezone quirks, an uncatchable Chuck Norris exception, and hash‑table choices—to help developers deepen their understanding of core Java concepts.
This article compares the two common ways to write infinite loops in Java—while(true) and for(;;)—exploring their origins, usage differences, and performance by examining JDK source counts and compiled bytecode, concluding they are functionally equivalent.
This article explains how PHP's case‑insensitive function handling can be accelerated by implementing a locale‑independent strtolower using SSE2 SIMD instructions in PHP 8, compares it with previous table‑lookup methods, and discusses a further Yaf‑specific optimization.
This article explains common Kafka interview questions by analyzing the system's high‑availability design, reliability mechanisms, consistency model, performance tricks such as sequential writes and zero‑copy, and the reasons for using Kafka and message queues, providing both conceptual insight and practical details.
This article outlines comprehensive development guidelines for Alibaba Cloud Redis, covering readable and concise key naming, avoiding big keys, proper command selection, safe client usage with connection pools, eviction policies, and practical code examples for deleting large hashes, lists, sets, and sorted sets.
The article outlines common cache challenges—consistency, breakdown, and avalanche—explains traditional three‑tier architectures, then details Tencent Cloud Redis Hybrid Storage’s unified interface, automatic hot‑data caching, dynamic TTL, atomic updates, and cost‑effective persistence, offering a scalable, reliable cache‑plus‑storage solution.
After upgrading a three‑shard MongoDB cluster from version 3.2 to 4.0, CPU usage jumped from 10 % to 40 % due to more frequent moveChunk operations and the resulting delete workload, as the balancer’s imbalance thresholds changed between versions.
The article details JD.com's advertising division's comprehensive backend engineering efforts—including traffic handling, data pipeline upgrades, memory optimization, and disaster‑recovery designs—to ensure system stability and performance during the high‑traffic 618 sales event.
This article investigates the Alibaba Java Development Manual's recommendation against joining more than three tables by experimentally evaluating multi-table join performance in MySQL and Oracle using massive synthetic datasets, analyzing query execution times, indexing effects, and providing data generation scripts and detailed results.
This article explains the principles behind Java thread pools, details the Executor framework, describes key parameters, provides formulas for calculating optimal thread counts for CPU‑bound and I/O‑bound workloads, and includes practical code examples and performance test results to help developers fine‑tune their thread pools.
This article explains Java's ArrayList structure, compares four traversal methods with benchmark code, analyzes their performance across different list sizes, and outlines safe deletion techniques and common pitfalls such as subList casting and concurrency issues.
This article presents thirty practical Python best‑practice tips covering version checks, IPython usage, list comprehensions, memory inspection, multiple return values, data classes, variable swapping, dictionary merging, string manipulation, ternary operators, counters, comparison chaining, color output, date parsing, integer division, character‑set detection and more, each illustrated with concise code examples.
This guide details Redis monitoring metrics across performance, memory, activity, persistence, and error categories, explains how to retrieve them with the INFO command, outlines useful monitoring tools, provides slowlog configuration examples, and includes command‑line snippets for performance testing and metric inspection.
This article shares practical dubbo-go experience at Tuya Smart, covering the gateway architecture, generic invocation mechanics, step‑by‑step integration, configuration pitfalls, performance tuning, and extension points to help developers adopt the high‑performance RPC framework efficiently.
Linus Torvalds rejected an AWS‑submitted patch intended to fix the Intel Snoop (CVE‑2020‑0550) side‑channel vulnerability, arguing it would degrade CPU performance for all Linux users, sparking debate over the patch's real security impact and its effect on virtualized environments.
An in‑depth comparison of PostgreSQL and Microsoft SQL Server examines their concurrency, partitioning, indexing, compression, cross‑platform support, and overall performance and scalability, concluding that PostgreSQL generally outperforms SQL Server across these parameters while offering more cost‑effective and flexible features.
This article walks through common interview questions on Linux memory monitoring and cache clearing, then dives into SQL join concepts, types, performance pitfalls, and practical optimization techniques for MySQL, providing clear explanations and actionable commands.
Phoronix benchmarked multiple PHP versions, including PHP 8 with and without JIT, revealing that PHP 8 offers modest gains over PHP 7.4 but a dramatic 92% speed increase when JIT is enabled, while older versions lag far behind.
Phoronix’s benchmark of PHP 8 (built from the latest Git source) compares it with PHP 7‑4, older 7.x releases, and legacy 5.x versions, showing a modest 7% speed gain without JIT and a dramatic 92% improvement when JIT is enabled, while highlighting I/O bottlenecks that limit gains in some tests.
This article outlines comprehensive development guidelines for Alibaba Cloud Redis, covering key naming conventions, value design, command best practices, client usage patterns, related tools, and detailed code examples for safely deleting large keys across various data structures.
This article presents a comprehensive guide to MySQL performance improvement, covering maximum data volume, connection limits, query latency targets, practical implementation principles, optimal table design, index classification and tuning, as well as detailed SQL optimizations such as batch processing, operator rewriting, and pagination techniques.
This guide outlines step‑by‑step methods to identify high load causes, troubleshoot replication interruptions, resolve instance hangs, and address common MySQL errors using commands like SHOW PROCESSLIST, EXPLAIN, iostat, and GTID management.
This article examines FastJson’s claim of speed by benchmarking it against Jackson and Gson, analyzes test results, discusses its popularity, highlights critical bugs in its timestamp handling, and ultimately recommends abandoning FastJson in favor of more widely adopted JSON libraries.
This article compiles essential Kafka interview topics, covering cluster sizing, partition and replica configuration, offset management, topic creation, log structure, election mechanisms, partition assignment strategies, handling data backlog, exactly‑once semantics, idempotence, transactions, and performance tuning with practical command examples.
This article explains the internal structure and working principles of Java's HashMap and ConcurrentHashMap, covering hash calculations, collision handling, resizing, the transition to red‑black trees, differences with TreeMap, LinkedHashMap, Hashtable, and performance‑related lock mechanisms in JDK 7 and JDK 8.
This article provides a comprehensive step‑by‑step guide for DBAs to safely upgrade MySQL from version 5.7 to 8.0, covering motivations, compatibility checks, new features, preparation tasks, upgrade commands, post‑upgrade verification, and rollback considerations.
ClickHouse is a column‑oriented, open‑source OLAP database developed by Yandex that offers high‑compression columnar storage, vectorized execution, and massive read/write throughput, making it ideal for large‑scale analytics while having specific usage scenarios and notable limitations such as lack of true transactions and secondary indexes.
This article compares Memcached and Redis, covering their installation, shared features such as sub‑millisecond latency and language support, and key differences in data structures, persistence, replication, transactions, pub/sub, geospatial commands, scripting, and memory efficiency to help you choose the right cache solution.
This article explains what software performance means, how to measure it with metrics such as response time and throughput, how to diagnose problems, visualize time and space contributions, and apply optimization principles, capacity planning, and testing to keep systems performant.
This article explains how leveraging edge computing, CDN‑based SSR caching, and TESI tags can dramatically improve first‑screen performance, reduce server pressure, and enable efficient static rendering for massive, mostly static content while maintaining up‑to‑date data and robust fallback mechanisms.
This article benchmarks Java's switch statement against equivalent if‑else chains using JMH, explains the underlying bytecode differences, shows how tableswitch and lookupswitch are generated, and demonstrates that switch can be up to 3.7 times faster as the number of branches grows.
The article introduces Alibaba's FastJson library, presents a benchmark showing it is only modestly faster than Jackson, discusses its limited popularity and numerous unresolved issues, and concludes that projects should prefer Jackson and gradually drop FastJson in favor of more reliable JSON parsers.
An engineer recounts a real‑world challenge of reusing existing SQL stored procedures to check a user's job, certification, and disclosure status, explores why inserting results into temporary tables can cause maintenance headaches, and concludes that moving business logic out of the database often yields cleaner, more maintainable code.
This article demonstrates how Swoole 4’s new coroutine kernel enables fully synchronous‑style PHP code to perform asynchronous I/O, file operations, database queries, and TCP/UDP networking within a single process, showcasing massive performance gains through practical code examples.
This guide walks through Oracle SQL execution steps, optimizer selection, table access methods, shared SQL caching, join order, index usage, query rewriting techniques, hint usage, and dozens of practical tips that together dramatically improve database performance while avoiding common pitfalls.
This article introduces essential JDK command‑line tools such as jps, jinfo, jstat, jmap, jhat and jstack, explaining their options, usage examples, and how they help developers monitor, diagnose and troubleshoot Java applications in production environments.
This guide walks through systematic troubleshooting of Java runtime issues—including CPU spikes, frequent garbage collection, memory leaks, disk bottlenecks, and network anomalies—by using Linux tools such as top, jstack, jstat, iostat, vmstat, and netstat, with concrete command examples and analysis steps.
Apache Dubbo 2.7.7, the high‑performance lightweight Java RPC framework, introduces major features such as Nacos authentication integration, LFU cache support, network interface selection, memory‑optimized Hessian2 instances, new load‑balancing strategies, plus numerous enhancements and bug fixes to improve reliability and performance.
This guide walks through a systematic approach to troubleshooting Java service outages, covering CPU, disk, memory, GC, and network problems, and demonstrates how to use tools such as ps, top, jstack, iostat, jstat, netstat, ss, and various dump commands to pinpoint and resolve the root causes.
