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.
This article provides a detailed guide to Swoole's millisecond‑precision timer API, covering the underlying epoll_wait/setitimer implementation, the static methods tick(), after(), clear() and additional utilities such as clearAll(), info(), list(), stats() and set(), with full syntax, usage examples and code snippets for both synchronous and asynchronous processes.
This article analyzes why Redis service nodes may experience massive TimeoutException errors, covering external influences such as CPU and memory contention, network resource exhaustion, and internal Redis usage issues like slow queries, persistence overhead, and configuration pitfalls, and provides concrete diagnostic commands and mitigation steps.
This article explains how Redis uses memory, covering memory fragmentation analysis, object and buffer memory consumption, sub‑process memory overhead, and practical configuration of maxmemory limits and eviction policies to optimize performance and prevent out‑of‑memory failures.
This article explains how HBase uses WAL and MemStore to create HFiles, describes the two compaction types (Minor and Major), and provides detailed recommendations for tuning key compaction-related configuration parameters to improve query performance and reduce HDFS impact.
This article introduces the Percona Toolkit utility pt‑stalk, explains its OS‑level and MySQL‑level monitoring capabilities, details configuration parameters and usage scenarios, shows example command lines, describes the generated diagnostic output, and briefly covers the companion pt‑sift tool for analysis.
This article presents practical front‑end optimization strategies, covering ES6 syntax shortcuts, efficient JavaScript array operations, careful use of closures and timers, as well as CSS tricks like sprites, animation, and avoiding repaint/reflow to improve website performance and cross‑browser compatibility.
This article presents comprehensive Java code optimization techniques, emphasizing error avoidance, reduced code size, and improved execution efficiency through practices such as using final modifiers, object reuse, local variables, proper resource handling, appropriate data structures, bitwise operations, and careful use of collections and concurrency utilities.
This article investigates the Alibaba Java Development Manual's recommendation to avoid joining more than three tables by designing and executing large‑scale MySQL and Oracle experiments, analyzing query performance, index impact, and data‑generation scripts to determine the practical limits of multi‑table joins.
The article recounts a detailed troubleshooting process—including data verification, code review, DBA assistance, local debugging, environment comparison, logging, packet capture, service restarts, async‑to‑sync changes, load testing, and Kafka partition tuning—that ultimately identified a Kafka partition bottleneck as the cause of a sudden data‑volume decline after a new feature went live.
The article explains MySQL 8.0.20's binlog transaction compression feature using the ZSTD algorithm, describes its internal implementation, outlines usage steps, presents performance test results, and lists important considerations for deploying compression in production environments.
The Tongtian Tower visual CMS team optimized its build, dependency packaging, and pre‑release workflows in Q1 2020 by migrating to webpack 4, parallelizing template builds, and improving FTP uploads, cutting total release time from 358 seconds to 160 seconds and saving roughly 7 hours of developer effort per week.
This article presents a comprehensive collection of Java code‑simplification techniques—from ternary operators and enhanced for‑loops to streams, Optional, design patterns, and aggressive dead‑code removal—showing how each shortcut can reduce boilerplate, improve readability, and boost performance in backend development.
This article explains how to use Arthas's tt (TimeTunnel) command to record method parameters, return values, timestamps, and execution details, compare it with the watch command, and replay recorded calls, accompanied by field definitions and a practical Java demo.
This article analyzes why StaggeredGridLayoutManager can cause item reordering and blank gaps at the top of a RecyclerView, explains the underlying measurement and layout mechanisms, and presents code‑level solutions such as disabling gap handling, invalidating span assignments, and using notifyItemRangeChanged instead of notifyDataSetChanged.
This article explains why MySQL master‑slave replication can suffer from latency, examines the root causes on both master and slave sides, and provides practical architectural, hardware, and configuration solutions—including semi‑sync and parallel replication—to improve data consistency and performance.
This guide explains how to use Arthas's trace command to capture Java method call paths, measure execution time for each node, handle class and method patterns, and highlights its limitations with lambda expressions, providing practical code examples and output analysis.
To accelerate CI/CD pipelines, the article recommends using self‑hosted GitLab Runners on a private cloud for faster network access, caching build dependencies, employing lightweight Alpine images for jobs, and limiting job execution to changed files via the only:changes rule.
This article details a comprehensive experiment that evaluates MySQL's ability to sustain up to 100,000 simultaneous connections using Percona Server's thread‑pool plugin, sysbench clients, adjusted OS/network limits, and multiple IP addresses, presenting hardware specs, configuration steps, observed errors, performance metrics, and practical recommendations.
Deno 1.0, the Rust‑written JavaScript/TypeScript runtime created by Ryan Dahl, introduces a CLI, a Rust‑based core, a new plugin system, and an HTTP server that handles about 25k requests per second with low latency, positioning it as a modern alternative to Node.js.
This article explores how Serverless computing reshapes front‑end development by tracing the evolution of front‑end architectures, introducing Serverless concepts and services, presenting practical frameworks, CLI tools, and code examples, and offering best‑practice guidance on testing, performance optimization, and deployment patterns for modern web and mini‑program applications.
This article analyzes a real e‑commerce incident to explain how RPC timeouts work in microservice architectures, why proper timeout and retry configurations are essential, and provides step‑by‑step guidelines for setting sensible timeout values while avoiding common pitfalls such as duplicate requests and retry storms.
Learn how to enable Zabbix’s VMware monitoring by configuring collectors, editing the server config, linking vCenter templates, adding CPU, memory, and disk usage items, and creating triggers, with detailed code snippets and screenshots to ensure comprehensive virtual machine performance tracking.
The article discusses a real‑world scenario where a developer tried to reuse existing stored procedures to determine the presence of Job, Certification, and Disclosure records, explores various T‑SQL techniques such as temporary tables and output parameters, and concludes that stored procedures are often unsuitable for simple boolean logic due to maintenance and reuse challenges.
This article details the comprehensive 2020 refactor of the Koudou internal purchase platform, covering front‑end architecture redesign, module‑based directory structure, performance optimizations, migration to Vue 2 with NutUI 2.x, TypeScript integration, API service modularization, and cross‑platform SDK handling.
This article categorizes and explains the most important HBase 1.1.2 configuration parameters—covering Region sizing, BlockCache strategies, Memstore thresholds, Compaction behavior, HLog handling, Call Queue tuning, and miscellaneous settings—while offering practical recommendations for optimal production deployment.
This article explains Nginx’s high performance by dissecting its multi‑process architecture, event‑driven model, HTTP connection handling, modular design, and I/O mechanisms, comparing it with Apache, and clarifying common questions about worker processes, maximum connections, and concurrency.
This article analyzes the default Android WebView loading process, identifies performance bottlenecks, and presents a multi‑stage optimization strategy—including custom caching, pre‑initializing the WebView, offline packages, and code examples—that reduces H5 page load time to under one second in the 58 Business app.
This article shares practical MySQL performance optimization techniques, covering table size limits, connection settings, data type choices, index design, query rewriting, pagination, and batch processing, with code examples and actionable guidelines to improve query speed and scalability.
Redis 6.0.0 GA, the biggest release to date, adds a redesigned client cache, ACL improvements, faster RDB loading, a new STRALGO command, and optional multithreaded I/O that can double network performance, while urging careful testing before production use.
This guide explains Tomcat’s role as a lightweight web server, details the required runtime environment, and provides step‑by‑step configurations for memory allocation, JVM options, connector concurrency, gzip compression, caching, security hardening, database connection pooling, and additional performance tweaks.
