This guide presents twenty practical Linux server optimization methods—from kernel elevator tuning and daemon reduction to TCP tweaks, secure backups, and effective monitoring commands—helping administrators enhance reliability, speed, and security while reducing resource consumption.
This guide explains why default Jenkins slave pods often suffer from slow builds or memory shortages, and provides concrete steps—adjusting CPU/memory limits, trimming plugins, using private artifact stores, disabling workspace cleanup, and configuring parallel stages—to dramatically improve Jenkins performance on Kubernetes.
SF Express’s data engineering team details how they migrated from a mixed‑component OLAP stack to a unified StarRocks platform, describing the evaluation criteria, performance‑critical design choices, import and query optimizations, and future roadmap for a high‑availability, low‑cost big‑data analytics solution.
This article provides practical guidance on server hardware selection, Linux kernel parameter tuning, and MySQL configuration adjustments to improve overall system performance, reliability, and efficiency for production environments.
This article introduces several MySQL performance‑tuning utilities—including mysqltuner.pl, tuning‑primer.sh, pt‑variable‑advisor, and pt‑query‑digest—explains how to download, install, and run them, and shows how to interpret their diagnostic reports to identify configuration issues and optimize database performance.
This article explains Spark's memory model, identifies common driver and executor OOM scenarios, and provides detailed configuration and code‑level recommendations—including memory‑related parameters and shuffle‑tuning options—to prevent and resolve out‑of‑memory failures in Spark applications.
This comprehensive article explains the inner workings of the Java Virtual Machine, covering class file structure, class loaders, memory layout, garbage collection, execution engine, debugging via JPDA, hot deployment, hot swapping, and performance tuning techniques, providing practical code examples and configuration tips.
This guide shares hard‑learned Linux operations lessons—testing before changes, rigorous backups, SSH hardening, firewall rules, monitoring, and systematic performance tuning—to help engineers avoid costly mistakes and keep services stable and secure.
This comprehensive guide explains the JVM memory layout, class‑loading and object‑creation process, the parent‑delegation model, various garbage‑collection algorithms and collectors, GC roots, triggers for YGC and Full GC, and practical tuning parameters to improve Java application performance.
This article explains the fundamentals, architecture, deployment patterns, recovery procedures, performance tuning, and common troubleshooting of MySQL Group Replication (MGR) as a high‑availability solution for private deployments, illustrated with real‑world examples and practical SQL commands.
This comprehensive guide covers MySQL fundamentals such as the three normal forms, differences between InnoDB and MyISAM, auto‑increment primary key behavior, index types and design principles, transaction isolation levels, MVCC, logging mechanisms, two‑phase commit, query execution, replication, high‑availability architectures, and practical performance tuning techniques.
By replacing the default Parallel GC with a ParNew‑CMS collector, enlarging the Young generation, fixing Metaspace settings, and tuning CMS occupancy thresholds, the video service cut Young and Full GC pauses dramatically, lowered Full GC count by over 80%, and achieved more than 30% P99 latency reduction, with some APIs improving up to 80%.
This article analyzes how to estimate per‑second request concurrency for a billion‑daily‑traffic e‑commerce order system, calculates memory usage per order, examines JVM heap and GC behavior, and proposes configuration adjustments to reduce Full GC occurrences during large‑scale promotions.
This guide shares practical Linux operations lessons—ranging from cautious command use, rigorous backup habits, and secure SSH configurations to comprehensive monitoring and performance tuning—to help teams avoid costly mistakes and maintain stable, reliable services.
This article explains which components—user processes, I/O wait, and system interrupts—consume most CPU in MySQL, describes the performance impact of high CPU, and provides concrete strategies such as reducing I/O, simplifying calculations, optimizing indexes, and judiciously scaling hardware to lower CPU usage.
This article presents a detailed performance test of HBase 2.x write throughput on a five‑node SSD cluster, identifies latency spikes caused by MemStore flush and ConcurrentSkipListMap size() overhead, and demonstrates how fixing the bug and applying in‑memory compaction dramatically reduces P999 and P9999 latency while preserving throughput.
This article explains the architecture of the OpenJDK HotSpot JVM, covering bytecode execution, JIT compilation, garbage collection, ergonomic defaults, configuration options, their lifecycle, and practical tuning advice to help developers optimize Java applications for various environments.
This article introduces essential JVM performance monitoring and profiling tools—including jps, jstack, jmap, jhat, jstat, and hprof—explaining their syntax, options, and practical usage for diagnosing memory leaks, thread deadlocks, high CPU consumption, and other common Java production issues.
This guide explains what Linux swap is, its advantages and drawbacks, how to size it for different memory configurations, and provides step‑by‑step commands for creating, managing, and tuning swap partitions or files, including swappiness and ZFS considerations.
This article compiles a series of JVM interview questions covering heap partitioning, garbage‑collection algorithms, collector types, memory coordination, tuning strategies, and practical tooling such as jstat, jmap, and MAT, providing detailed explanations and command‑line examples for each topic.
This article extends previous Elasticsearch cheat sheets with practical commands and step‑by‑step instructions for shard allocation, replica adjustment, cluster settings, slow‑log configuration, mapping routing, force merge, bulk writes, refresh intervals, translog durability, heap sizing, disk‑space monitoring, and troubleshooting strategies.
This article examines Dubbo’s connection‑control feature, demonstrates how long‑living TCP connections are created, runs benchmark tests with one and two connections, discovers that varying IO thread counts skew results, and shows that increasing connections alone rarely improves throughput.
Drawing from three and a half years of system administration, this article outlines practical guidelines for safe online operations, data protection, server security, continuous monitoring, performance tuning, and the right mindset to avoid costly mishaps in production environments.
This article provides a comprehensive overview of the Java Virtual Machine memory layout, explaining each region such as the heap, metaspace, stack, program counter, direct memory and code cache, along with allocation strategies, tuning parameters, and practical OOM demonstrations.
This guide outlines essential steps for scaling large Kubernetes clusters on public clouds, covering node quota adjustments, kernel parameter tuning, etcd high‑availability setup, API server and pod configurations, and best‑practice recommendations to ensure stable performance as node counts grow.
The article describes how Ant Group operates a world‑largest Kubernetes deployment of over 10,000 nodes, details the performance challenges of the etcd key‑value store at such scale, and outlines a comprehensive set of hardware upgrades, configuration tuning, monitoring, data‑splitting, and future distributed‑etcd strategies to achieve robust high‑availability.
During a performance test a MySQL server showed one CPU core constantly at 99% while the others were idle, prompting a detailed investigation that checks I/O thread settings, multi‑core utilization, transaction locks, slow‑query logging, and index optimization to resolve the bottleneck.
This article provides a comprehensive guide to Kubernetes Scheduler, covering its architecture, extension points, API, node affinity, taints and tolerations, scheduling bottlenecks, priority classes, and performance tuning techniques to optimize pod placement in large clusters.
This article explains why MySQL queries using LIMIT with a large offset become extremely slow, demonstrates the inefficiency through a 950‑million‑row table example, and shows how rewriting the query with a sub‑select join reduces execution time from seconds to milliseconds while preserving results.
This article provides a comprehensive introduction to Elasticsearch, covering its underlying Lucene-based inverted index, data types, shard routing, cluster roles, discovery mechanisms, refresh and translog handling, segment merging, and practical performance and JVM tuning tips for building scalable, near‑real‑time search systems.
This article explains the need for a messaging system, explores Kafka's core concepts, cluster architecture, performance optimizations like sequential disk writes and zero‑copy, and provides detailed guidance on sizing hardware, configuring producers and consumers, and managing a production Kafka deployment.
This article explains the different Cloud MySQL instance architectures, details asynchronous, semi‑synchronous, and strong synchronous replication, describes high‑availability failover mechanisms, outlines upgrade procedures, and covers binlog usage, rollback methods, slow‑query optimization, and storage fragmentation.
This guide introduces four practical MySQL performance‑tuning utilities—MySQLTuner, 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.
The article explains why MySQL can hit the max_connections limit, introduces the MySQL 8.0 administrative connection interface and its configuration variables, demonstrates how to create a privileged user and test connection limits with code examples, and offers best‑practice recommendations to prevent connection saturation.
This article presents a comprehensive guide on optimizing Elasticsearch for large‑scale data platforms, covering Lucene fundamentals, index and shard architecture, doc‑values usage, routing strategies, practical performance‑tuning techniques, and real‑world testing results to achieve sub‑second query responses on billions of records.
The article shares the author’s experience reading the third edition of "Understanding the JVM," focusing on JVM memory management, garbage‑collection algorithms, tuning strategies, and practical tools, while providing concise summaries of each book section and actionable advice for Java performance optimization.
This article explains how Tencent's Light platform reduced the massive overhead of feature hashing in ad‑ranking by moving integer‑to‑string conversion and hash computation to the GPU, introducing custom contiguous string tensors, and achieving up to 12× speed‑up on V100 GPUs.
This article explains which components (user processes, IO wait, system interrupts) consume CPU in MySQL, shows their impact on performance, and provides practical strategies to reduce CPU usage through IO optimization, query tuning, data modeling, caching, and hardware upgrades.
This comprehensive guide walks you through MySQL performance tuning, covering how to monitor server status, identify slow queries, use EXPLAIN for execution plans, create and manage various index types, and apply practical SQL optimizations such as import tricks, insert batching, efficient GROUP BY/ORDER BY, and pagination improvements.
The article recounts a real‑world incident where a Java HttpClient connection‑pool misconfiguration limited each host to only two connections, causing massive thread queuing, CPU spikes, and ultimately a cascade of instance crashes during traffic scaling.
Over a month of systematic JVM tuning reduced Full GC from 40 times per day to once every ten days and halved Young GC duration by adjusting heap sizes, survivor ratios, and metaspace settings while investigating and fixing a memory leak caused by an anonymous inner class listener.
This article provides a detailed exploration of SparkSQL, covering its evolution from Shark, core components, execution workflow, Catalyst optimizer, various optimization strategies, and practical configuration tips for achieving high performance in big‑data processing.
This article demonstrates how to trigger and interpret JVM garbage‑collection logs by creating a small Java program, configuring heap parameters, and dissecting both young and full GC log entries to reveal causes, memory changes, and performance implications.
This article examines a real‑world Oracle SQL query, identifies costly full‑table scans and low‑selectivity columns, and demonstrates how creating an index on a key column reduces execution time from 24 minutes to just one second, highlighting essential SQL performance‑tuning techniques.
This article explains NUMA architecture with hyper‑threading, details CPU cache hierarchies and access latencies, and provides Linux tools and practical optimization techniques to improve cache‑hit rates and minimize cross‑NUMA memory delays.
This article explains the purpose of the TCP TIME-WAIT state, the scenarios it protects against, common misconceptions, and practical Linux kernel tweaks—such as fast recycle, socket reuse, and tw_buckets settings—to manage TIME-WAIT efficiently on high‑concurrency servers.
This article provides a practical guide to tuning Linux kernel parameters and NGINX configuration directives—such as backlog queues, file descriptors, worker processes, keepalive connections, access‑log buffering, sendfile, limits, caching and compression—to achieve optimal web server performance for high‑traffic sites.
After a new feature rollout caused a sudden CPU surge and thousands of Dubbo threads to stall, this article walks through log inspection, code review, thread‑dump analysis, and memory‑leak detection to uncover the root cause and suggest concrete optimizations.
Over a month, we reduced Full GC occurrences on a 2‑core, 4 GB JVM cluster from roughly 40 times per day to once every ten days, while halving Young GC duration, by adjusting heap parameters, fixing memory leaks, and tuning metaspace, ultimately improving server throughput and stability.
This article introduces core JVM performance and monitoring utilities—including jps, jstack, jmap, jhat, jstat, and hprof—explains their command syntax, demonstrates practical steps to locate high‑CPU threads, analyze heap dumps, and interpret GC statistics, and provides concrete code examples for Java developers.
This article details Kuaishou's Flutter audio-video implementation, optimization practices, and engineering support, covering video playback via external textures, data communication strategies, FFI integration, and performance tuning.
This article provides an overview of the most common Java JVM garbage collectors—including Serial, ParNew, Parallel, Serial Old, CMS, Parallel Old, and G1—detailing their characteristics, advantages, disadvantages, typical usage scenarios, and JVM tuning parameters for optimal performance.
Over a month of JVM tuning, the author reduced Full GC from more than 40 times per day to once every ten days and halved Young GC duration by adjusting heap sizes, fixing memory leaks, and tuning metaspace, ultimately improving server throughput and stability.
This guide compiles all JVM garbage‑collection parameters—standard, non‑standard, and experimental—explaining their meanings and how to configure them to minimize pause times, improve performance, and tailor GC behavior for different application types and hardware environments.
This article provides a comprehensive overview of Kafka Producer configuration properties, categorizing them into basic and performance‑related parameters, explains their impact on producer behavior, and offers practical guidance for tuning throughput, latency, and reliability in real‑world deployments.
Over a month of systematic investigation, the author reduced Full GC occurrences on a 2‑core, 4 GB Java server cluster from 40 times a day to roughly once every ten days by adjusting heap settings, fixing a memory‑leak caused by an anonymous listener, and tuning Metaspace and CMS thresholds, ultimately achieving stable performance and lower latency.
This article examines MySQL InnoDB spin‑lock tuning by adjusting innodb_spin_wait_delay and innodb_sync_spin_loops, describing spin‑lock mechanics, detailing an experiment with performance_schema metrics, and concluding that modest spin settings are preferable to aggressive tuning.
This article provides a comprehensive guide to JVM performance tuning, covering the JVM architecture, runtime data areas, various garbage collectors, configuration flags for heap and GC settings, and practical recommendations for selecting the optimal GC strategy based on workload characteristics.
This article presents an extensive collection of MySQL performance‑tuning techniques, covering index design, query rewriting, use of UNION and EXISTS, temporary tables, NOLOCK hints, join limits, backup strategies, storage engine choices, data‑type selection, and other practical tips to improve query efficiency and overall database reliability.
Understanding JVM garbage collection with the CMS collector involves grasping class‑loader hierarchies, memory regions such as Young, Old and Metaspace, the multithreaded ParNew young collector, CMS’s four‑phase mark‑sweep‑compact cycle, and applying tuning parameters—like survivor ratios, tenuring thresholds, and concurrent marking options—to minimize stop‑the‑world pauses and full GCs on typical 4‑core, 8 GB servers.
This article documents a month-long JVM garbage‑collection tuning effort on a 2‑core, 4 GB server cluster, detailing initial problems with frequent FullGC, successive configuration adjustments, memory‑leak investigations, and the final optimizations that cut FullGC occurrences and significantly improved overall throughput.
This article explains Java thread pool fundamentals—including core parameters, task submission behavior, rejection policies, queue selection, thread factory usage, keep-alive settings—and provides practical guidance on determining optimal thread counts for I/O‑bound and CPU‑bound workloads.
This guide explains how to identify MySQL max‑connection errors, check the current limit, and increase it using configuration files, global variables, source‑code changes, or mysqld_safe adjustments, with detailed commands and code examples for various MySQL versions.
This article shares ten practical pitfalls encountered when moving hourly Spark session jobs to Flink, covering parallelism load imbalance, state TTL, checkpointing strategies, logging, JMX debugging, state migration risks, reduce vs process choices, input data validation, event‑time handling, and external storage considerations, along with concrete configuration snippets and performance tips.
This article provides an in‑depth overview of the Java Virtual Machine, covering JDK/JRE/JVM relationships, compilation process, class loading mechanisms, the parent‑delegation model, runtime memory areas, garbage collection algorithms and collectors, and practical JVM performance tuning tips for backend developers.
This article examines Ceph’s architecture, identifies performance bottlenecks on Huawei’s Kunpeng ARM platform, and presents practical tuning methods—including NUMA placement, cache tagging, vector acceleration, thread scaling, and monitoring tools—to improve storage efficiency, reduce latency, and lower power consumption.
This article provides a comprehensive overview of Java thread pools, covering their advantages, internal workflow, creation parameters, various execution states, shutdown procedures, performance tuning strategies, and key monitoring metrics, supplemented with practical code examples.
This article explores Java's thread pool framework in depth, covering its advantages, internal workflow, creation parameters, task submission, lifecycle states, tuning strategies, monitoring metrics, and common pitfalls, providing code examples and practical guidance for effective concurrency management in backend applications.
This article explains the core components of the Java Virtual Machine, including its memory regions, class loading process, object allocation strategies, garbage‑collection algorithms, and tuning tools, providing a comprehensive guide for developers to optimize Java applications.
This guide explains the most important Tomcat configuration parameters—including concurrency, thread pool, JVM settings, and key Connector options—so you can optimize the web container for higher throughput and lower latency without getting lost in hundreds of obscure options.
This guide details comprehensive Flink performance tuning techniques, covering memory configuration, GC settings, parallelism adjustments, process parameters, partitioning strategies, Netty network tuning, checkpoint optimization, and common issues such as data skew and resource bottlenecks.
This article explains advanced Spark performance tuning techniques, focusing on diagnosing and resolving data skew and shuffle bottlenecks through stage analysis, key distribution inspection, and a variety of practical solutions such as Hive pre‑processing, key filtering, parallelism increase, two‑stage aggregation, map‑join, and combined strategies, while also covering ShuffleManager internals and related configuration parameters.
This article shares practical experience with TiDB Data Migration (DM), covering its background, architecture, key features, online DDL support, common error handling such as duplicate‑key issues, large‑scale import tuning, configuration limits, and cleanup recommendations for reliable MySQL‑to‑TiDB synchronization.
This article provides step‑by‑step guidance on importing data into Kudu via Sqoop and Impala, performance tuning recommendations for Impala‑Kudu workloads, best practices for queries, data deletion, comparisons with Parquet, and a brief overview of StreamSets as an ETL tool.
This guide outlines key hardware planning, SSD usage, BIOS settings, Linux and Ceph configuration tweaks, PG calculations, and performance tuning commands to optimize a Ceph distributed storage cluster for maximum throughput and reliability.
This article investigates why an InfluxDB 1.8 instance on a 32‑core, 64 GB server consumes over 58 GB of resident memory and generates heavy disk I/O, examines Go runtime memory accounting, uses system tools such as top, pmap, pprof and iostat for diagnosis, and presents configuration and runtime tweaks that reduce memory pressure and I/O load.
The article investigates why an InfluxDB 1.8 instance on a 32‑core, 64 GB production server consumes over 95% memory and generates heavy disk I/O, analyzes runtime statistics, pprof data, and Go memory‑release behavior, and presents configuration and runtime tweaks that reduce memory usage to ~55% and I/O load to acceptable levels.
This article walks through a systematic SQL optimization workflow—identifying slow queries, interpreting EXPLAIN output, using SHOW PROFILE and TRACE, applying concrete tuning measures, and dissecting ten representative MySQL cases ranging from index ordering to large‑page handling and complex query pitfalls.
A Pulsar community expert investigated why MultiTopicsConsumerImpl delivered only a fraction of the expected throughput, identified lock contention and EventLoop overhead as the main culprits, applied lock‑removal and thread‑pool optimizations, and achieved nearly four‑fold performance gains.
This article describes how to improve the performance of a massive MySQL 5.6 user‑log table by redesigning schema, applying proper indexes, using partitioning, considering table sharding, and evaluating upgrade paths to compatible cloud or big‑data databases, with concrete SQL examples and cost analysis.
This guide walks you through customizing Nginx error pages, enabling and reading the built‑in status module, boosting worker and connection limits, adjusting header buffer sizes, and configuring browser caching for static assets, all with concrete commands and configuration examples.
This article explains the architecture and core concepts of Elasticsearch and Lucene, outlines the requirements for cross‑month and high‑speed queries on massive datasets, and provides detailed index and search performance tuning techniques—including bulk writes, shard routing, doc‑values management, and pagination strategies—to achieve sub‑second response times on billions of records.
This article explains why Kuaishou needed a dedicated online messaging system, how RocketMQ was chosen and integrated, the deployment strategies, client SDK design, load‑balancing and disaster‑recovery mechanisms, diverse message features, distributed reconciliation monitoring, and performance‑tuning parameters.
This step‑by‑step tutorial shows how to configure Linux kernel limits, set up multiple client IPs, and run PHP‑based server and client scripts to achieve and monitor over one million concurrent TCP connections on a single machine.
This article provides a thorough overview of Redis, covering its core data structures, common commands, persistence options, memory management, pipelining, transactions, performance optimization, replication, clustering, and Java client choices for developers and architects.
This article explains why the team built a dedicated online messaging system, the scenarios where Kafka fell short, the decision to adopt RocketMQ, deployment strategies, SDK design, load‑balancing, distributed monitoring, and performance tuning tips for a robust backend solution.
This article walks through a real‑world LNMP case where slow backend responses and 502 errors were diagnosed and resolved by analyzing Nginx logs, increasing file descriptor limits, adjusting FastCGI timeouts, and fine‑tuning PHP‑FPM settings, followed by performance testing with ApacheBench.
After upgrading an internal framework, a company’s UAT environment saw throughput drop from 53.9/s to 6.4/s due to abnormal Feign latency, prompting a deep dive with Arthas profiling, code tracing, and class‑loader analysis that uncovered costly JodaModule loading and class‑loader overhead, leading to targeted fixes that restored and even improved performance.
This article demonstrates a step‑by‑step method for diagnosing MySQL hangs by collecting callstack information, identifying mutex conflicts, and mapping function calls to code locations to pinpoint the root cause of deadlocks.
This article compiles essential JVM interview topics, covering ClassLoader mechanisms, Java memory layout, garbage collection concepts and algorithms, as well as practical performance tuning techniques, providing links to detailed resources and common interview questions for each area.
This article documents a MySQL slow‑query case where a 5‑million‑row table took over 30 seconds to execute, explores several ineffective optimization attempts, uncovers a client‑side LIMIT issue, and finally resolves the performance problem by forcing the use of the idx_end_time index, cutting the runtime to under a second.
This article explains how to diagnose and optimize Flink jobs by first examining metrics, then checking resource allocation, analyzing throughput and back‑pressure, and finally tuning JVM settings, while providing concrete configuration examples and practical tips for big‑data practitioners.
This comprehensive guide walks through the Java Virtual Machine's runtime data areas, memory model, heap layout, garbage‑collection mechanisms, HotSpot internals, performance tuning flags, and class‑loading process, providing developers with the essential knowledge to optimize Java applications.
At Youzan, Flink real‑time tasks running on Kubernetes are optimized by daily GC‑log memory analysis and Kafka‑throughput monitoring, which compute recommended heap sizes and parallelism adjustments to eliminate over‑provisioned CPU and memory, automate alerts, and pave the way for fully automated resource tuning.
This article details a step‑by‑step performance tuning journey for a Java‑based SOA service, covering thread‑pool redesign, memory‑allocation adjustments, and JIT compilation tweaks that together lifted QPM by nearly 40% and overall system throughput by about 50%.
This comprehensive guide explains the JVM memory layout, object allocation, garbage collection mechanisms such as mark‑sweep, copying, and mark‑compact, details GC roots, reference types, collector types, tuning parameters, and related Java performance tools, providing practical code examples and diagrams.
This guide shows how to increase the number of concurrent TCP connections on a Linux server by adjusting kernel parameters, expanding file descriptor limits, and understanding the underlying socket structures and lookup mechanisms that govern connection handling.
This article summarizes a year‑long performance tuning of an ELK logging system, analyzing bottlenecks such as write thread pool saturation, JVM heap and GC settings, refresh intervals, translog durability, merge threads, shard and replica counts, and provides concrete configuration changes that reduced latency, eliminated data loss, and stabilized node resource usage.
This article explains why MySQL queries become slow by examining write‑operation issues such as dirty‑page flushing and locking, read‑operation problems like missing indexes and buffer‑pool evictions, and provides practical steps to diagnose and prevent these performance bottlenecks.
This guide explains how to optimize Linux kernel parameters and Nginx settings—such as file descriptor limits, TCP queue lengths, temporary ports, worker processes, KeepAlive, and log buffering—to significantly improve server performance and handle high traffic loads.
