Facing frequent timeouts in a high‑throughput Java service, we traced instability to long GC pauses during massive index swaps, then systematically tuned JVM parameters, explored G1, ZGC, and custom Eden‑pre‑heating techniques, ultimately achieving near‑perfect availability without adding hardware.
This article explains how to use MySQL's EXPLAIN command to analyze slow queries, interprets each field in the execution plan, provides practical examples and optimization techniques, and offers advanced diagnostics for improving index usage and overall SQL performance.
Learn how to permanently disable SELinux, set runlevel to 3, increase file descriptor limits, fine‑tune kernel sysctl parameters, configure firewall settings, and resolve common Linux performance issues such as too many open files and connection timeouts to dramatically improve server throughput.
This article walks you through diagnosing slow MySQL queries using EXPLAIN, fixing index issues, reordering joins, forcing optimal indexes, monitoring index usage, and applying systematic governance such as SQL sanitization and sharding to dramatically improve performance.
This article explains how to import 1 billion 1 KB log records stored in HDFS or S3 into MySQL by analyzing single‑table limits, using batch inserts, choosing storage engines, sharding, optimizing file‑reading methods, and coordinating distributed tasks with Redis, Redisson, and Zookeeper to ensure ordered, reliable, and high‑throughput data loading.
This article explains various situations that cause MySQL indexes to become ineffective—such as leading wildcard LIKE queries, calculations on indexed columns, use of functions, data type mismatches, improper use of composite indexes, and character set differences—providing example SQL, execution plans, and practical testing steps.
This article systematically examines MySQL optimization techniques for both read‑many/write‑few and write‑many/read‑few business scenarios, covering architecture design, caching, sharding, asynchronous processing, monitoring, and emerging NewSQL/HTAP solutions to achieve high performance, consistency, and scalability.
This article humorously introduces a common interview scenario and then provides a comprehensive overview of JVM garbage collection, covering memory regions, GC roots, collector types like ParNew, G1, CMS, tuning parameters, code examples, and practical tips for diagnosing and optimizing GC behavior.
This guide compiles a comprehensive set of SQL Server commands for administrators, covering version checks, server and database properties, connection statistics, backup and restore procedures, user and role management, performance diagnostics, cache cleanup, and various maintenance tasks to streamline daily operations.
Learn how the open‑source hcache tool analyzes Linux page‑cache usage, provides global and per‑process cache rankings, supports multiple output formats, and offers step‑by‑step installation and command examples to pinpoint memory hogs, troubleshoot OOM alerts, and optimize system performance.
This guide explains how to optimize Nginx by configuring worker processes, CPU affinity, file descriptor limits, event handling, efficient file transfer, connection timeouts, FastCGI, gzip compression, caching, anti‑hotlinking, kernel parameters and system limits for high‑traffic web services.
This article provides a thorough tutorial on SQL fundamentals, including statement order, core clause rules, templates for SELECT/INSERT/UPDATE/DELETE, practical multi‑table query cases, join and subquery techniques, common pitfalls, index optimization strategies, experimental performance data, and a structured learning path for mastering database development.
This guide explains how to permanently disable SELinux, set the system runlevel, enlarge file descriptor limits, fine‑tune kernel networking parameters via /etc/sysctl.conf, configure firewall settings, and troubleshoot common Linux socket errors to significantly improve server performance.
This article explains why SQL statements become performance bottlenecks as data grows, outlines a systematic optimization workflow—including slow‑query identification, EXPLAIN analysis, profiling, and tracing—and discusses practical solutions for index usage, query rewriting, pagination, range queries, and large‑scale data handling in MySQL.
This article explains the Java memory pool model, common Out‑of‑Memory errors, their root causes, tuning parameters, and real‑world case studies to help developers diagnose and resolve OOM issues in containerized Java applications.
By dropping a low‑selectivity composite index, adding targeted indexes on product_id‑sequence‑station_no and receive_time, and using online DDL with pt‑osc, the team reduced row scans and replication lag, then implemented batch deletions by primary‑key ranges, cutting delete time from minutes to seconds on a 100‑million‑row table.
This article explains why Spring Boot applications can consume up to 12 GB of RAM, demonstrates how to inspect JVM memory with tools like jps and jmap, clarifies default heap size calculations, and provides practical steps to tune JVM parameters for production stability.
The article explains MySQL's Index Merge optimization, detailing its three types—Intersection, Union, and Sort‑Union—when it is beneficial, how to design indexes and rewrite queries for better performance, and the associated costs and limitations.
The article provides an in‑depth technical analysis of Linux’s memory reclamation system, covering zones, watermarks, page flags, LRU lists, the shrink_zone workflow, kswapd, direct reclaim, OOM handling, page‑cache structures, and practical tuning tips for optimal performance.
This article compiles the most frequently asked MySQL interview questions, covering fundamentals, storage engines, SQL optimization, indexing, transaction handling, replication, sharding, and performance troubleshooting to help readers master both theory and practical usage.
This article introduces the high‑performance in‑memory queue Disruptor, covering its architecture—including ring buffer, sequence, sequencer, and wait strategies—its key features such as multicast events and lock‑free concurrency, and provides practical tuning advice and a complete Java example.
This article provides a comprehensive guide to speeding up Spring Boot application startup by explaining configuration principles, code‑level interventions, lazy loading, dependency reduction, auto‑configuration exclusion, logging adjustments, compile‑time optimizations, and caching strategies, all illustrated with practical Java examples.
This article explains how to size and configure JVM options—including heap size, young generation, GC algorithm, thread stack, and metaspace—for a backend service that processes one million login requests per day on an 8 GB machine, providing step‑by‑step calculations, practical examples, and optimization tips.
Learn how to permanently disable SELinux, set runlevel to 3, increase file descriptor limits, fine-tune kernel network parameters via /etc/sysctl.conf, configure firewall settings, and address common Linux performance issues such as too many open files and TIME_WAIT overloads.
Discover ten validated Spring Boot 3 performance optimization techniques—including lazy initialization, JVM tuning, connection pooling, caching, async processing, virtual threads, and Actuator monitoring—complete with configuration snippets and code examples, to accelerate startup, reduce memory usage, and improve response times for Java backend services.
This article explains why MongoDB sharding is required for scaling storage and performance, describes the shard, config server, and mongos components, outlines range, hash, and compound sharding strategies, and provides practical guidance on shard key selection, balancing, backup, tuning, and security.
This article breaks down essential thread‑pool parameters, explains how to set corePoolSize and maximumPoolSize for CPU‑ and IO‑bound tasks, and outlines a practical, dynamic adjustment process—including monitoring, strategy definition, load testing, and automation—to achieve optimal performance in production environments.
This guide walks through identifying slow MySQL queries using EXPLAIN, explains each output field, and presents practical optimization techniques—including proper index usage, pagination tricks, join improvements, and ORDER/GROUP BY tuning—to dramatically boost query performance.
This article explains five essential Nginx parameters—worker_processes, worker_connections, keepalive_timeout, gzip compression, and file‑caching settings—along with practical examples and code snippets to dramatically improve high‑concurrency handling on servers.
This article explains the Java memory model, outlines common OutOfMemoryError types, and provides a step‑by‑step guide for diagnosing, fixing, and preventing memory‑related issues in large‑scale Java applications, including heap, metaspace, and stack analysis, JVM flag tuning, and best‑practice recommendations for resource handling and monitoring.
This guide introduces four powerful MySQL performance‑tuning utilities—mysqltuner.pl, tuning‑primer.sh, pt‑variable‑advisor, and pt‑query‑digest—explaining how to download, run, and interpret their reports to identify configuration issues, memory overload, and slow‑query problems.
This guide walks through the end‑to‑end flow of SQL execution on Alibaba MaxCompute (ODPS), explains how to use Logview to pinpoint performance bottlenecks, enumerates common causes of slow queries, and presents concrete optimization techniques such as MapJoin hints, double‑group‑by rewrites, TRANS_COLS, bucket partitioning and UDF tuning, all illustrated with step‑by‑step examples and visual diagrams.
This article explains how CPU caches bridge the speed gap between the processor and main memory, describes cache hierarchy, locality principles, write policies, coherence protocols, and provides concrete C code examples and practical tips such as data alignment and loop restructuring to improve cache hit rates and overall program speed.
This article walks through a systematic, eight‑step approach to sizing and configuring JVM memory parameters—including heap, young generation, stack, object age thresholds, and garbage‑collector selection—so that a service handling one million daily logins on an 8 GB machine can achieve stable performance and predictable GC behavior.
This article explains common interview questions on frequent Full GC and high CPU usage in Java backend development, detailing root causes, JVM parameter adjustments, memory leak prevention, and code optimization techniques, along with practical code examples and tool recommendations for effective performance tuning.
This guide explains why Tomcat's default development settings need tuning for production, covering JVM memory model basics, configuration file edits, thread pool and connector adjustments, as well as security hardening steps to improve performance and stability.
This guide explains how to optimize Tomcat by adjusting maxThreads, acceptCount, maxConnections, and connectionTimeout, while also tuning Linux kernel parameters, TCP settings, and JVM options to achieve balanced CPU and I/O performance for high‑concurrency web services.
This article introduces MySQL performance tuning utilities—including mysqltuner.pl, tuning-primer.sh, pt-variable-advisor, and pt-query-digest—provides download and usage commands with report‑analysis guidance, and then shifts to promotional content for ChatGPT‑4.0 services, a paid community, and related offers.
Facing high costs and scaling limits with ClickHouse, we migrated a 4000‑core, 500TB OLAP workload to StarRocks, achieving 40% cost reduction, 50% storage savings, and up to 30× query speedups through storage‑compute separation, materialized‑view rewrites, and extensive performance tuning.
Redis can appear slow for many reasons—including baseline latency differences, high‑complexity commands, big keys, concentrated expirations, memory limits, fork overhead, huge pages, CPU binding, swap usage, memory fragmentation, and AOF configuration—so this guide explains each cause, how to diagnose it, and practical optimization steps.
This guide walks through identifying Java processes that cause high CPU load, extracting the hottest threads with top and jstack, analyzing JVM memory regions, interpreting GC logs, and applying practical JVM tuning parameters and tools such as jmap, jstat, and MAT to resolve performance bottlenecks.
This article introduces the Disruptor in‑memory message queue, explains its core components such as Ring Buffer, Sequence, Sequencer and Wait Strategies, describes its distinctive features like multicast events and lock‑free concurrency, and provides tuning guidelines and a complete Java example.
This article explains how to plan capacity, choose the appropriate garbage collector, allocate heap and non‑heap memory, and configure JVM flags—including Xms, Xmx, Xmn, Xss, and GC‑specific options—to reliably support a service node with 8 GB RAM handling one million login requests per day.
This article presents a detailed case study of a severe service outage caused by Log4j2 asynchronous logging bottlenecks, explains step‑by‑step diagnostics of JVM, disk, and RingBuffer metrics, and demonstrates how adjusting log4j2.asyncQueueFullPolicy and log4j2.discardThreshold dramatically improves recovery time during load testing.
This article introduces four open‑source MySQL performance tools—mysqltuner.pl, tuning‑primer.sh, pt‑variable‑advisor, and pt‑query‑digest—explaining their purpose, how to download and run them, and how to interpret the diagnostic reports they generate for database optimization.
This guide explains how to use iostat and related Linux commands to monitor I/O performance, interpret key metrics such as %util, await, and svctm, and apply practical analysis and optimization techniques for diagnosing and resolving storage bottlenecks.
This article explains how multi‑table joins in MySQL can become performance bottlenecks and walks through the four join algorithms—Simple Nested‑Loop, Block Nested‑Loop, Hash, and Index Nested‑Loop—showing their execution plans, code examples, and step‑by‑step optimizations using indexes and join buffers to dramatically improve query speed.
This article examines Spark SQL expression-level optimizations, focusing on redesigning LIKE ALL and LIKE ANY to reduce memory and stack usage, refactoring the TRIM function for better code reuse and performance, and implementing constant folding to cache computed constant expressions, thereby enhancing query efficiency in big-data workloads.
To keep Nginx fast under heavy load, adjust worker processes and connections to match CPU cores, enable gzip compression, set browser and proxy caching headers, turn on sendfile with optimal chunk and TCP settings, tune log levels, and optionally use a CDN and HTTP/2.
This guide explains how to optimize Kubernetes API Server performance by configuring the max-mutating-requests-inflight limit and watch-cache-size, offering recommended values for different cluster sizes, monitoring metrics, and step‑by‑step adjustment strategies for stable, high‑throughput clusters.
This article explains the five major Elasticsearch query limits—including result size, max clause count, field data, join operations, and query throughput—detailing their default values, why they exist, and practical solutions such as using search_after, scroll API, and resource monitoring to keep clusters stable and performant.
This article walks through practical MySQL performance tuning methods—including pagination, join, subquery, ORDER BY, GROUP BY, and COUNT optimizations—illustrated with real‑world data volumes, step‑by‑step SQL examples, EXPLAIN analyses, index creation, and measurable query‑time improvements.
This article explains Hadoop’s core concepts using a library analogy, details HDFS storage and MapReduce processing, provides complete Java implementations for a word‑count job with support for text, CSV, and JSON inputs, and discusses extensibility and performance optimizations such as combiners and custom partitioners.
This article walks through a systematic approach to sizing and configuring JVM parameters—including heap size, young generation, GC algorithm selection, and advanced options—for a high‑traffic login service that processes one million requests per day on a server with 8 GB of memory, while explaining the underlying performance‑analysis methodology.
By deduplicating logs and assigning compact numeric tags to each user‑dimension combination, the data‑tagging method replaces costly lateral‑view expansions with a user‑level aggregation, cutting shuffle volume from terabytes to gigabytes and reducing runtime from 49 minutes to 14 minutes, enabling scalable multi‑dimensional user‑count analysis for Baidu Feed.
This article explains the need for vector databases in the AI era, reviews PostgreSQL's extensible ecosystem, compares vector‑database options, provides step‑by‑step PgVector installation and usage, shares operational best practices, performance tuning tips, and real‑world Qunar & Tujia case studies.
This article explains, step by step, how to estimate capacity, choose the appropriate garbage collector, size the young and old generations, configure stack memory, adjust object aging thresholds, and fine‑tune CMS or G1 settings so that a Java service handling one million daily logins can run reliably on an 8 GB node.
This article explains how database administrators can monitor system resources with commands such as top, iostat, and vmstat, and how to enable and inspect MySQL slow query logs, while also including promotional information about a ChatGPT community and related services.
This article explains ZGC’s ultra‑low pause times, massive heap support, colored pointers, concurrent compaction, and generational optimizations, then shows how these features benefit real‑time analytics, high‑performance servers, and online transaction systems, and provides step‑by‑step instructions for enabling and tuning ZGC in Java.
This article explains why MySQL master‑slave replication can become delayed in high‑traffic order systems, describes the underlying binlog synchronization mechanism, and provides practical steps—including network upgrades, server tuning, transaction reduction, version updates, and slave count limits—to eliminate the lag.
A recent CCF‑A conference paper reveals that an adaptive K‑value backoff lock, derived from queueing theory and implemented in Apache RocketMQ, can replace both spin and mutex locks, achieving up to 37.58% performance gains on x86 CPUs and 32.82% on ARM while reducing CPU usage and resource consumption.
This article details a comprehensive engineering practice for optimizing AI inference services at ZhiZhuan, covering background analysis, selection of TorchServe over alternatives, GPU/CPU performance tuning, custom handlers, Torch‑TRT integration, and deployment on Kubernetes, with measured improvements in throughput and resource utilization.
This article presents a comprehensive guide for Java engineers on MySQL query optimization, covering index usage, avoiding SELECT *, proper JOINs, efficient WHERE clauses, LIMIT, EXISTS vs IN, function indexes, connection pooling, batch processing, data types, execution plan analysis, materialized views, and regular performance monitoring, all illustrated with practical code examples.
This article provides a detailed, practical guide for increasing Redis memory on Linux by adjusting Redis configuration, expanding system swap space, tuning kernel overcommit settings, and monitoring usage with command‑line tools.
Learn 25 practical Linux performance tuning techniques—from adjusting kernel parameters like swappiness and ulimit to optimizing I/O schedulers, network buffers, and enabling HugePages—each with clear commands and step‑by‑step instructions to help you maximize system responsiveness and throughput.
To efficiently purge old user‑operation logs while retaining the most recent three months and preserving type‑c entries, the article recommends abandoning offset pagination and MyBatis PageHelper, using primary‑key‑based pagination with a tracked startId, in‑memory filtering, intelligent startId recalculation, and optional sleep intervals to avoid database overload.
This article details a real-world performance optimization of a high‑concurrency Java backend interface, reducing response time from 30 seconds to under 0.8 seconds through SQL analysis, array aggregation, moving logic to PostgreSQL, and introducing Caffeine caching, with code examples and lessons learned.
This guide explains why MySQL and Java processes can exceed 900% CPU usage in production, and provides step‑by‑step methods—using top, show processlist, jstack, index tuning, caching, and code adjustments—to diagnose, mitigate, and prevent such spikes.
The article investigates why a RocketMQ consumer service running on a 4‑core ECS experiences sustained high load despite low CPU, I/O and memory usage, identifies excessive thread creation and frequent trace‑module context switches as the main causes, and proposes configuration and SDK upgrades to resolve the issue.
This guide explains how to optimize Nginx settings and adjust Linux kernel parameters—such as worker processes, connection limits, caching, HTTP/2, rate limiting, and TCP tweaks—to reliably handle massive traffic spikes while maintaining high availability and performance.
This article provides a comprehensive, step‑by‑step guide to tuning Kunpeng‑based servers, covering hardware characteristics, matrix‑multiplication benchmarks, NUMA‑aware scheduling, compiler and JDK optimizations, acceleration libraries, disk and NIC tuning, and a practical MariaDB performance‑tuning workflow.
This comprehensive guide covers Nginx's history, core features, modular architecture, installation methods, global performance tuning, and detailed HTTP, server, and location directives, providing practical code examples and configuration snippets for building high‑performance web services.
This article explains how to troubleshoot a slow OceanBase stored procedure by locating its trace_id, analyzing audit logs to identify non‑cached UPDATE statements, revealing that preceding TRUNCATE operations invalidate the plan cache, and finally recommending replacing TRUNCATE with DELETE to restore performance.
This article examines the key pain points of massive AI compute clusters—including heterogeneous hardware compatibility, efficient scheduling, training and inference acceleration, and fault‑tolerant operations—while presenting practical management and performance‑tuning strategies, a cloud‑native AI platform implementation, and future directions for the ecosystem.
This guide introduces four popular MySQL performance‑tuning utilities—mysqltuner.pl, tuning‑primer.sh, pt‑variable‑advisor, and pt‑query‑digest—provides download commands, usage examples, and detailed tips for interpreting their diagnostic reports to improve database configuration and query efficiency.
This article explains the necessity of vector databases for AI workloads, reviews the PostgreSQL ecosystem, compares vector database options, provides detailed PgVector installation and usage steps, shares operational best‑practices, performance tuning tips, and real‑world deployment cases at Qunar and Tujia.
The article presents three RLHF‑PPO acceleration techniques—TRT‑LLM‑based text generation speedups, selective activation recomputation with sequence parallelism for dynamic memory reduction, and overlapping pipeline stages for system‑level parallelism—demonstrating a 350 % throughput boost on a 10 B model using 16 A100 GPUs.
This article explains the purpose, evolution, configuration parameters, and step‑by‑step maintenance procedures for MySQL Undo tablespaces, covering versions from pre‑5.6 to 8.0 and providing practical commands for viewing, creating, truncating, and dropping Undo tablespaces.
This guide outlines a structured way to answer interview questions about thread pool principles, covering key parameters, execution flow, rejection policies, illustrative analogies, and common pitfalls to demonstrate deep understanding.
This guide covers practical MySQL performance improvements, including choosing proper data types, avoiding SELECT *, optimizing joins and UNION usage, batch inserts, query cache settings, configuration parameters like innodb_buffer_pool_size, and comprehensive index strategies to accelerate queries and reduce resource consumption.
This article examines why the unified content platform switched from MongoDB to HBase, outlines HBase’s high‑performance, scalability, and consistency features, and details four optimization techniques—including cluster upgrade, connection pooling, column‑read strategy, and compaction tuning—that significantly improved read/write latency and operational stability.
This article outlines practical production‑level optimizations for Apache Doris compaction, covering vertical, segment, and single‑replica compaction methods, compaction policies, concurrency controls, and data‑ingestion tuning to improve import speed and query performance in OLAP workloads.
This article provides a thorough guide to MySQL performance optimization, covering general query improvements, proper data types, index usage, configuration parameter tuning, avoiding common pitfalls, and detailed EXPLAIN analysis, with concrete SQL examples and practical recommendations for developers and DBAs.
This comprehensive guide explains Nginx's high‑performance architecture, module system, multi‑process model, FastCGI integration, configuration best practices, tuning techniques, error troubleshooting, and a known PHP‑related vulnerability, providing practical steps for optimal deployment on Linux servers.
This article explains the limitations of MySQL's built‑in query cache, how the InnoDB buffer pool works and can be tuned, and introduces ReadySet as an external caching middleware to improve query performance after a major product upgrade.
This article presents a real‑world case study of a high‑concurrency data‑processing interface whose response time was reduced from 30 seconds to under one second by diagnosing SQL bottlenecks, refactoring MyBatis code, applying PostgreSQL array aggregation, and introducing a Caffeine cache, while also discussing the limits of relational databases and promoting related AI services.
This article explains the JVM memory architecture, object lifecycle, young and old generation garbage‑collection mechanisms, tuning goals such as low latency, high throughput and large heap, and provides practical advice on monitoring, common memory‑related problems, and choosing appropriate collectors for different application scenarios.
This technical report describes the current high‑resource MySQL deployment, analyzes disk, table‑space, QPS and slow‑SQL issues, and presents a set of governance goals and concrete solutions—including data migration, query interception, and read‑from‑slave strategies—backed by code samples, tables and scripts to reduce load and improve stability before a major sales event.
This comprehensive guide explains the fundamentals of HotSpot CMS garbage collection, identifies nine typical GC problem scenarios, analyzes their root causes, and provides practical tuning strategies, code examples, and diagnostic tools to help Java engineers optimize performance and avoid costly pauses.
This article presents twenty practical SQL optimization techniques—including index usage, selective column queries, avoiding functions in WHERE clauses, replacing subqueries with joins, limiting result sets, using EXISTS, batch inserts, covering indexes, proper data types, pagination, and transaction management—to significantly improve query performance and database efficiency.
In 2023, a TapTap infra team reduced Redis operating costs by 460,000 CNY per month through low‑cost ESSD instances, traffic compression, unused‑instance cleanup, TTL management, data migration, online compression, and targeted cleaning, detailing ten concrete measures and the open‑source tools that enabled zero‑downtime optimization.
A single runaway SQL caused a 12‑hour outage of a core Oracle system; the article walks through the fault symptoms, AWR and ASH analysis, abnormal SQL identification, execution‑plan changes caused by partition operations, and the step‑by‑step remediation that restored performance.
This article explains how to obtain the SQL ID, create an outline bound to that ID, and correctly verify its effect in OceanBase, highlighting common pitfalls such as using the wrong schema or relying on EXPLAIN, and provides practical code examples for each step.
This guide explains how to enable detailed G1 GC logging in Java, interprets both Minor (YGC) and Full GC log entries, breaks down heap size changes, worker threads, pause times, and points to the GCEasy analysis tool for deeper insight.
This article explains Java Metaspace and metadata GC thresholds, compares PermGen with Metaspace, and provides detailed JVM flag configurations—including size settings and compressed pointer options—to help developers optimize memory usage and garbage‑collection performance.
This article outlines the main directions for server performance tuning—CPU, memory, disk, and network—explains the typical workflow of metric collection, bottleneck analysis, and parameter optimization, and provides a curated list of recent CPU industry reports and technical resources.
This guide explains how to tune Tomcat 8.5 by adjusting server.xml parameters such as maxThreads, acceptCount, maxConnections, and connectionTimeout, while also covering related Linux kernel settings, file‑descriptor limits, and JVM options to achieve optimal concurrency and response times.
This article explains how implicit type conversions in PostgreSQL can cause index loss, drastically misestimate row counts, and force inefficient join strategies, illustrating the issue with concrete examples, detailed execution plans, and step‑by‑step optimizations that restore index usage and boost performance thousands of times.
This article explains the principles, features, and workflow of Java's Z Garbage Collector, provides detailed configuration and logging guidance, and shares AutoMQ's practical tuning experiences that achieve sub‑millisecond pause times and improved performance for latency‑sensitive backend services.
This document outlines a detailed training curriculum covering backend development, cloud-native technologies, microservice frameworks, databases, messaging systems, containerization, orchestration, performance tuning, and related tools, presented as a series of numbered sessions with practical labs and theory.
