This article explains how to optimize Hive on Spark running on YARN, covering YARN node resource configuration, Spark executor and driver memory settings, dynamic allocation, parallelism, and key Hive parameters to achieve superior performance compared to Hive on MapReduce.
This case study details the migration of Weimeng's MySQL databases to Tencent Cloud CDB, describing the testing methodology, performance bottlenecks discovered (NUMA, network parameters, low‑concurrency issues, and version bugs), the step‑by‑step optimizations applied, and the resulting QPS improvements across various workloads.
This guide walks through the most frequent Java production problems—high CPU, high load, continuous Full GC, thread‑pool saturation, and NoSuchMethodException—explaining their causes, diagnostic commands, and practical remediation steps to restore service stability.
The article explains how maintaining an optimal number of HBase regions (typically 20‑200 per RegionServer) and appropriate region size, along with careful MemStore and compaction settings, can prevent memory pressure, reduce GC pauses, and enhance overall cluster stability and throughput.
This article explains common IO latency problems, introduces how to define and refine IO models, lists disk and network evaluation tools, describes key monitoring metrics, and provides practical tuning methods and case studies for improving storage and network performance.
This article provides an extensive overview of Java Virtual Machine fundamentals for interview preparation, covering JVM components, runtime data areas, heap vs. stack memory, garbage collection mechanisms, algorithms, collectors, memory allocation strategies, class loading processes, and tuning tools.
This article explains how to size and tune Druid's connection pool for high‑traffic Java applications, covering pool‑size formulas, timeout settings, keep‑alive behavior, essential XML properties, and version recommendations to prevent misleading SQL latency and improve overall database stability.
This guide introduces four open‑source MySQL tuning utilities—mysqltuner.pl, tuning‑primer.sh, pt‑variable‑advisor, and pt‑query‑digest—explains how to download and run each tool, and shows how to interpret their AWR‑style reports for concrete performance and security improvements.
This article provides a comprehensive step‑by‑step guide for installing, configuring, and performance‑tuning the Rainbond (formerly CloudHelp) Kubernetes‑based platform, covering prerequisites, FAQ, installation commands, node addition, kernel and system parameter adjustments, and post‑installation verification.
Senior DBA Yang Jianrong shares how standardized processes, robust security, and modern optimization—such as partitioning, middleware, and NoSQL—combined with high‑availability designs and self‑service tools like automated slow‑log analysis can streamline large‑scale MySQL operations, migrations, and continuous DBA learning.
A comprehensive collection of SQL Server commands covering server properties, configuration, system views, monitoring, backup, replication, Always On, file management, index operations, and troubleshooting techniques for database administrators.
This article examines production JVM memory architecture, explains GC log generation and analysis, details the ParNew + CMS collector behavior, and provides practical parameter tuning recommendations to optimize heap size, young generation, and garbage collection for stable Java applications in production environments.
This article provides a comprehensive guide to tuning Linux kernel parameters and NGINX configuration directives—such as backlog queues, file descriptors, worker processes, keepalive settings, access log buffering, sendfile, and limits—to achieve optimal web server performance for high‑traffic sites.
Learn how to optimize Java applications by configuring six critical JVM parameters—including heap size, Metaspace limits, GC algorithm selection, logging, heap dumps, thread stack size, and network timeouts—while understanding their impact on performance, memory usage, and troubleshooting common out‑of‑memory issues.
This article presents a detailed summary of Meituan's Spark optimization techniques, covering development‑level RDD tuning, resource parameter configuration, data‑skew mitigation, shuffle improvements, and the advantages of using DataFrame/Dataset APIs for better performance.
Facing massive MySQL tables that take days to alter, 360's cloud team migrated to TiDB and discovered instant online DDL, fast column additions, efficient COUNT(*) queries, seamless MySQL‑to‑TiDB migration, and a suite of tuning knobs that keep disk usage low and performance high across billions of rows.
This guide introduces four open‑source MySQL diagnostic utilities—MySQLTuner, tuning‑primer.sh, pt‑variable‑advisor, and pt‑query‑digest—explaining how to download, run them against a live server, interpret the generated AWR‑style reports, and apply the recommended configuration changes for better stability and speed.
This guide introduces four key MySQL optimization utilities—mysqltuner.pl, tuning-primer.sh, pt-variable-advisor, and pt-query-digest—explains how to download, install, and run each tool, and shows how to interpret their health‑check reports to identify performance bottlenecks, configuration issues, and security risks.
This guide shares practical Linux server operation rules, emphasizing thorough testing, careful use of destructive commands, strict access control, regular backups, security hardening, continuous monitoring, and disciplined performance tuning to prevent costly outages and data loss.
This article shares the experience of deploying TiDB on the 360 Cloud Platform, covering background challenges with massive tables, TiDB's online DDL and high‑performance features, cluster architecture, DM migration workflow, common operational issues, and detailed tuning parameters to improve latency, QPS, and resource utilization.
The article explains Spark’s executor memory layout under the UnifiedMemoryManager, detailing on‑heap and off‑heap divisions, the four memory regions, default fraction settings, how storage and execution memory share space, and provides heuristics and tuning tips for avoiding OOM and optimizing performance.
This article explains how to tune Hive on Spark by adjusting driver, executor, and Hive configuration parameters—including CPU cores, memory allocations, dynamic allocation, and join thresholds—to achieve optimal performance when running on YARN.
This guide explains how to design and deploy a Kafka production cluster—including capacity planning for 1 billion daily messages, hardware sizing, key configuration parameters, command‑line operations, and useful management tools—to achieve reliable high‑throughput streaming.
This article explains the nature of scalar subqueries, identifies three common performance pitfalls, and provides practical rewrite techniques—including LEFT/INNER JOIN, MERGE, and WITH‑MATERIALIZE—illustrated with three real‑world Oracle SQL cases to dramatically reduce execution time.
This article explains how to optimize HBase performance by properly configuring JVM memory, selecting suitable garbage‑collection strategies, enabling MSLAB and BucketCache, and adjusting read/write cache ratios to reduce fragmentation and improve throughput.
This article provides a comprehensive overview of Java's automatic garbage collection, covering memory regions, identification methods, core algorithms such as mark‑sweep, copying, and generational collection, detailed explanations of various collectors (Serial, CMS, G1, etc.), and practical tuning insights for optimal performance.
This article presents a concise collection of twelve actionable SQL tuning techniques—including using proper comparison operators, LIMIT 1, appropriate data types, breaking large statements, UNION ALL, consistent query formatting, avoiding SELECT *, indexing WHERE/JOIN/ORDER BY columns, pagination with LIMIT, and leveraging EXPLAIN—to help developers improve database performance.
This article explains what server concurrency means, how to measure it with throughput and stress testing, and presents practical techniques such as CPU parallelism, reducing context switches and lock contention, using persistent connections, optimizing I/O models, and scaling hardware to boost overall server performance.
This guide explains the most important JVM parameters—such as -Xms, -Xmx, -Xss, and various -XX options—detailing how each setting influences heap, stack, and generation sizes and how proper configuration can avoid common OutOfMemoryError scenarios in Java applications.
This article explains how to diagnose and optimize Linux system performance by examining hardware resources, OS configuration, storage setups like RAID, network bandwidth, and application code, offering a step‑by‑step guide for administrators and engineers to achieve optimal efficiency.
This guide provides a comprehensive walkthrough of Redis configuration options, covering memory unit notation, include templates, module loading, security settings, networking, persistence mechanisms, replication, clustering, Docker deployment, monitoring, and advanced memory and performance tuning.
This article examines the shortcomings of a Storm‑based real‑time metric platform, outlines the requirements for a stable, SQL‑driven, fast engine, and explains why ClickHouse was chosen over Presto, detailing performance benchmarks, architectural advantages, cluster configuration, engine options, best practices, and common operational issues.
The author describes how a high‑traffic promotion system using HttpClient suffered massive thread and port exhaustion due to misconfigured connection‑pool parameters, details the investigation steps—including monitoring, jstack analysis, and source code review—and outlines corrective measures and preventive testing strategies.
This article presents eight practical MySQL optimization techniques—including smarter LIMIT usage, implicit type conversion fixes, join rewrites, mixed sorting, EXISTS elimination, condition pushdown, early row limiting, and intermediate result pushdown—each illustrated with SQL examples and performance comparisons that reduce query times from seconds to milliseconds.
This article presents concrete MySQL optimization techniques—including smarter LIMIT usage, avoiding implicit type conversion, rewriting updates and deletes with JOINs, handling mixed ordering, replacing EXISTS with joins, pushing down conditions, and leveraging WITH clauses—to dramatically reduce query execution times from seconds to milliseconds.
This article explains the architecture of Elasticsearch and Lucene, outlines common performance bottlenecks, and provides concrete indexing and search optimization techniques—including bulk writes, shard routing, doc values tuning, and pagination strategies—to achieve sub‑second query responses on billions of records.
This article provides a comprehensive overview of the G1 (Garbage First) collector, covering its region-based memory layout, cross‑generation reference handling, SATB write barriers, various GC phases (Young, Mixed, Full), and how to interpret detailed G1 GC logs for performance tuning.
This article examines a MySQL instance that hit 100% CPU at 9 am on 2019‑01‑11, identifies the offending ORDER BY query through slow‑log and EXPLAIN analysis, and demonstrates how adding a composite index and correcting implicit type conversions reduced execution time from over 10 seconds to milliseconds.
This article explains how a data platform handling billions of daily records can be optimized for cross‑month queries and sub‑second response times by tuning Elasticsearch indexing, shard routing, Lucene structures, and hardware configurations.
This guide explains how to optimize disk I/O on Kunpeng processors by outlining the underlying performance bottlenecks, introducing essential monitoring tools like iostat, and detailing practical kernel and filesystem tuning methods—including dirty page settings, read-ahead adjustments, I/O scheduler selection, and XFS configuration.
This article presents a comprehensive guide to optimizing Elasticsearch for massive data volumes, covering Lucene fundamentals, index and shard design, practical performance‑tuning techniques, and real‑world testing results that enable cross‑month queries and sub‑second response times.
This article examines common MySQL performance pitfalls such as inefficient LIMIT usage, implicit type conversion, suboptimal joins, mixed sorting, and unpushed predicates, and demonstrates eight practical rewriting techniques—including using max values, JOINs, WITH clauses, and early range reduction—to dramatically accelerate query execution.
This article explains the fundamentals of the CMS (Concurrent Mark Sweep) garbage collector, presents a comprehensive set of JVM parameters optimized for HBase clusters, and provides detailed analysis of key settings to improve performance and reduce GC pauses.
This guide walks through JVM performance tuning fundamentals, when to tune, core principles, quantitative goals, step‑by‑step procedures, key parameters, and concrete memory, latency, and throughput optimization examples with code snippets and analysis tools.
In an interview, Tencent Cloud senior engineer Chen Xi explains how Tencent optimizes Elasticsearch for massive log, monitoring, and document search workloads by prioritizing stability through kernel tweaks, boosting performance with scenario‑specific settings, cutting costs via redundant storage trimming and off‑heap indexing, and leveraging rich data‑pipeline components and robust distributed cluster management to lower operational overhead while anticipating future ecosystem growth and community collaboration.
This article introduces the most common JVM performance problems in enterprise Java applications and provides a practical guide to using core monitoring and tuning tools such as jps, jstack, jmap, jstat and hprof, complete with command syntax, sample outputs and step‑by‑step troubleshooting examples.
This article provides a comprehensive overview of the JVM memory model, garbage collection algorithms, various collectors and their trade‑offs, class loading steps, object lifecycle, escape analysis, and practical tuning commands for optimizing Java applications.
MySQL 8.0.18 adds the EXPLAIN ANALYZE feature, which runs a query and reports actual execution times, row counts, and loop iterations, enabling developers to compare estimated costs with real performance and fine‑tune their queries for better efficiency.
This comprehensive guide explains MySQL’s logical architecture, common performance bottlenecks, and practical techniques for writing efficient SQL, designing tables, configuring parameters, and optimizing indexes to maintain system stability during updates and scaling.
This article introduces the Kunpeng processor’s NUMA architecture, contrasts it with traditional SMP designs, and presents a practical five‑step methodology for performance optimization, helping developers on Kunpeng platforms achieve better scalability and efficiency through targeted memory‑access tuning.
This article presents a structured, repeatable approach for Talend data‑integration jobs that guides readers through pinpointing performance bottlenecks, testing individual pipeline stages, and applying targeted optimizations to sources, targets, and transformations to achieve higher throughput and more reliable ETL processes.
The article shares a database expert’s experience with three types of Oracle bugs—internal errors, slow execution plans, and incorrect results—explains why they occur, offers concrete fixes such as patching and session parameters, and outlines essential skills for reliable SQL development.
Long garbage collection pauses can degrade Java application performance and SLA, so this guide outlines seven practical steps—including reducing object allocation rates, increasing young generation size, selecting appropriate GC algorithms, avoiding swap usage, tuning GC threads, managing I/O load, and limiting System.gc() calls—to minimize pause times.
This comprehensive guide walks you through MySQL optimization philosophy, risk management, stakeholder involvement, practical tools, hardware and system tuning, kernel parameter adjustments, and detailed MySQL configuration tweaks to achieve both performance gains and reliable stability in production environments.
This comprehensive guide explains MySQL optimization philosophy, required participants, key dimensions, essential tools, step‑by‑step tuning procedures, hardware and system tuning, and detailed MySQL and InnoDB parameter settings to improve performance and reliability.
This article analyzes the performance bottlenecks of a MongoDB‑based CMDB under high write concurrency, explains index structures and storage, demonstrates how to identify and eliminate full‑table scans and redundant multikey indexes, and shows the resulting reduction in slow‑log volume and CPU usage.
This article explains how to assess, monitor, and tune system I/O performance by defining I/O models, selecting appropriate evaluation tools, tracking key metrics for disk and network I/O, and applying practical optimization strategies for both storage and network bottlenecks.
This guide walks through MySQL's query process, optimization philosophy, required participants, dimensions, tools, and detailed hardware, system, and configuration tuning steps, providing actionable commands and code snippets to improve database stability, security, and performance.
This guide shares practical steps to overcome TIME_WAIT port exhaustion on macOS and optimize Apache HttpClient settings for high‑concurrency load testing, including sysctl tweaks for maximum file descriptors, port range adjustments, connection‑pool parameters, timeout configurations, and a custom connection‑recycling thread, enabling over 20 k concurrent requests without bottlenecks.
This article explains what huge pages are, why they can improve memory performance, provides step‑by‑step instructions to enable them for MySQL on CentOS, shows how to verify the configuration, and shares test results that reveal little performance gain.
This article details JD.com’s order center journey from a simple Elasticsearch deployment to a highly available, dual‑cluster architecture, covering isolation, replica tuning, hot‑cold data separation, version upgrades, and practical lessons on pagination, field data, and doc values.
This article introduces CB‑SQL, a MySQL‑compatible elastic database built on CockroachDB and RocksDB, explains RocksDB’s LSM‑tree design, details key configuration parameters, and describes the read/write/clear/file‑operation optimizations employed by CB‑SQL to achieve high scalability and stability.
This article explains how to improve Spark and Spark Streaming performance by tuning serialization, broadcast variables, parallelism, batch intervals, memory usage, garbage collection, and Kafka integration, providing practical code examples and real‑world optimization results.
This article provides a comprehensive overview of Elasticsearch, covering its role in handling structured and unstructured data, core concepts such as Lucene, inverted indexes, clusters, shards, replicas, mapping, indexing processes, storage mechanisms, and practical performance tuning tips for deployment.
This article presents a comprehensive MySQL interview guide covering index types and optimization, transaction concepts and isolation levels, table schema design best practices, storage engine differences, and common performance issues such as large pagination and slow query analysis.
This guide walks you through MySQL's query process, the philosophy and risks of optimization, the key participants, core dimensions such as hardware, system, schema and SQL, essential diagnostic tools, emergency and regular tuning steps, system‑level monitoring, kernel and user limits, as well as detailed MySQL and InnoDB configuration parameters for achieving high performance and reliability.
The article recounts a production incident where a GC alert triggered due to excessive object creation in a scheduled ad‑transaction sync task, and explains how the problem was diagnosed, mitigated by task splitting, and finally resolved through data sharding across multiple machines.
This article lists the most frequent Java OutOfMemoryError cases—including Java heap space, GC overhead limit exceeded, PermGen/Metaspace, native thread creation failures, array size limits, and direct buffer memory—explains their root causes, and provides practical troubleshooting steps and JVM tuning parameters to resolve them.
This article presents practical MySQL performance tricks—including smarter LIMIT usage, avoiding implicit type conversion, rewriting UPDATE/DELETE with JOIN, handling mixed ordering, replacing EXISTS with JOIN, pushing down conditions, narrowing result sets early, and leveraging WITH clauses—to dramatically reduce query execution times.
The author describes a sudden 30,000‑second slowdown in a simple MySQL join query, details systematic diagnostics—including network, server load, and query testing—and ultimately discovers a missing index on the user_info table, restoring it to bring response times back to sub‑second levels.
This article explains how to assess and improve system I/O performance by defining I/O models, selecting appropriate evaluation tools for disk and network, monitoring key metrics such as IOPS, bandwidth and latency, and applying host, network, and storage‑side optimization techniques for high‑throughput and low‑latency workloads.
This article explains the G1 (Garbage‑First) garbage collector introduced in JDK7, its region‑based architecture, key differences from CMS, and the complete GC cycle—including Young GC, concurrent phases, mixed GC, and Full GC—while providing real‑world log examples and performance insights for Java developers.
This article explains how to use MySQL's EXPLAIN and EXPLAIN EXTENDED commands to analyze query execution plans, interpret each column such as id, select_type, type, and extra, and apply practical optimization techniques like indexing, avoiding full‑table scans, and forcing index usage to improve SQL performance.
This article provides a comprehensive, step‑by‑step guide to MySQL performance tuning, covering the underlying query process, optimization philosophy, practical tools, system‑level diagnostics, hardware and OS recommendations, as well as detailed configuration parameters for both the server and storage engine.
This article provides a comprehensive guide to improving Hive query performance by covering column and partition pruning, predicate pushdown, replacing ORDER BY with SORT BY, using GROUP BY instead of DISTINCT, fine‑tuning join operations, and optimizing MapReduce parameters such as mapper/reducer counts, file merging, compression, JVM reuse, parallel execution, strict mode, and storage formats.
This article presents a comprehensive guide to Java application performance optimization, covering OS‑level and JVM‑level diagnostics, profiling tools, GC analysis, JVM tuning, application‑code refactoring, and database‑layer adjustments, illustrated with real‑world case studies and code examples.
This article presents twelve practical SQL optimization techniques—from using proper comparison operators and LIMIT clauses to indexing strategies and query consistency—to dramatically improve database query speed and overall application performance.
This article examines frequent MySQL performance problems such as inefficient LIMIT pagination, implicit type conversion, sub‑query updates, mixed ordering, EXISTS usage, condition push‑down limits, early result set reduction, and intermediate result set optimization, providing rewritten SQL examples that dramatically improve execution speed.
Meltwater details how it processes millions of daily media posts using a custom‑tuned Elasticsearch 1.7.6 cluster of over 400 nodes on AWS, covering data volume, query complexity, node configuration, indexing strategy, performance optimizations, and lessons learned for large‑scale search deployments.
This article compiles practical ELK knowledge, covering character‑set conversion, removing unwanted log lines, Grok pattern handling for multi‑line logs, multiline plugin usage in Filebeat and Logstash, date filtering, log type classification, performance optimization, Redis buffering, and Elasticsearch node tuning.
This article provides a comprehensive overview of the Java Virtual Machine, detailing its main components, runtime data areas, class loading mechanism, garbage collection algorithms and collectors, heap vs stack differences, object reclamation criteria, and common JVM tuning tools and parameters.
This guide outlines practical Linux operations standards, covering safe testing, backup habits, multi‑user coordination, security hardening, continuous monitoring, performance tuning methods, and the right mindset to avoid costly mistakes in production environments.
This article explains MySQL's logical architecture, query processing steps, and the inner workings of its optimizer, cache, and execution engine, then offers practical performance‑tuning advice on schema design, index creation, and specific query patterns to help developers make informed optimization decisions.
This guide details comprehensive Nginx performance optimization, covering worker process sizing, CPU affinity, file descriptor limits, event model settings, HTTP directives, fastcgi parameters, gzip compression, expires caching, anti‑hotlinking, and essential Linux kernel tweaks for high‑traffic servers.
The NetEase News team improved video playback by analyzing the production and playback pipelines, prioritizing reading and buffering, and applying client‑side techniques such as preloading, fine‑grained caching and adaptive buffer control, selecting ExoPlayer for Android, optimizing file layout and CDN strategies, and using data‑driven measurements, ultimately reaching a 94% instant‑play rate with minimal stutter and failure.
When a critical Oracle 10g database on AIX spikes to 100% CPU, this detailed case study walks through emergency actions, AWR analysis, hidden bottlenecks, and practical tuning steps that reduced CPU usage by half and restored system stability.
YouZan’s experience with Flume shows how the at‑least‑once delivery model, combined with FileChannel storage and custom extensions such as an NsqSource, hourly‑based HdfsEventSink, metric reporting server, and timestamp interceptor, can reliably move MySQL binlog data to HDFS, while tuning transaction batch size and channel capacity boosts throughput and stability, paving the way for a unified management platform.
A SAP month‑end CO module query suffered severe slowdown despite standard index hints, prompting a deep dive into execution plans, statistics, and a little‑known num_index_keys hint that dramatically improves IN‑list iterator access and reduces filter overhead.
This article explains the essential concepts, philosophy, participants, dimensions, tools, and step‑by‑step procedures for safely and effectively optimizing MySQL databases, covering hardware, system, application, and MySQL‑level tuning together with practical command‑line examples.
This article explains MySQL's logical architecture, query processing steps, and the inner workings of the optimizer, then provides practical performance‑tuning advice covering data types, index design, cache usage, and specific query patterns such as COUNT, JOIN, LIMIT pagination and UNION.
An in‑depth guide to MySQL optimization covering the query execution process, risk‑aware philosophy, hardware and system tuning, essential diagnostic tools, practical SQL and index adjustments, and comprehensive configuration settings to boost performance while maintaining stability and security.
This article explains how Spark's memory management models and configuration parameters can be tuned to handle massive billing data efficiently, covering StaticMemoryManager vs UnifiedMemoryManager, storage and shuffle memory fractions, common OOM and file‑not‑found issues, and practical performance‑optimisation tips.
This article outlines the philosophy, risks, participants, and step‑by‑step strategies for MySQL optimization, covering query flow, hardware and system tuning, configuration parameters, monitoring tools, and SQL‑level improvements to achieve stable, high‑performance database operations.
This article explains the fundamentals of relational optimization, the role of the optimizer, how CPU and I/O costs are estimated, and why accurate database statistics are essential for effective SQL performance tuning.
Meltwater’s media‑monitoring platform runs a custom Elasticsearch 1.7.6 cluster of over 400 nodes on AWS, handling 200 TB of primary data and 3 million daily documents while serving thousands of complex queries per minute, achieved through careful shard design, master‑node configuration, extensive performance tuning, and automated provisioning.
This comprehensive guide explains the purpose, lifecycle, trade‑offs, common issues, and performance‑tuning strategies of Java's Concurrent Mark‑Sweep (CMS) garbage collector, helping developers understand when it runs and how to configure it for low‑latency applications.
To alleviate GPU scarcity, iQIYI’s cloud platform migrated deep‑learning inference to CPUs and applied system‑level (MKL‑DNN, OpenVINO), application‑level, and algorithm‑level optimizations—tuning threads, batch size, NUMA, pruning and quantization—delivering 1‑9× speedups across thousands of cores while preserving latency and accuracy.
Meituan’s DSP system boosted high‑QPS ad serving performance by layering an LRU cache in front of Redis, then adding time‑based eviction, sharding the cache into HashLruCache instances to cut lock contention, and employing a zero‑copy, reference‑counted design, ultimately cutting average latency to about 20 % of the original and similarly reducing 99.9th‑percentile delays.
This article explains the origins, design goals, and detailed mechanisms of Java's G1 garbage collector—including regions, CSet, RSet, SATB, the full collection cycle, common pitfalls, and practical tuning recommendations—to help developers achieve predictable pause times and high throughput.
This comprehensive guide explains Redis fundamentals, its rich data structures and common commands, then dives into performance optimization, replication, and clustering, offering practical examples and best‑practice recommendations for building reliable, high‑performance Redis deployments.
