This article introduces four open‑source MySQL performance‑tuning utilities—mysqltuner.pl, tuning-primer.sh, pt-variable-advisor, and pt-query-digest—explains how to download, install, run them, and interpret their reports to identify configuration issues and slow‑query problems.
This article provides an end‑to‑end analysis of AI inference bottlenecks, reviews common industry acceleration techniques, and details Baidu Intelligent Cloud’s AIAK‑Inference suite—including its architecture, optimization strategies such as model pruning, operator fusion, and single‑operator tuning—followed by a demo showing significant latency reductions on ResNet‑50 and other models.
While distributed clusters are popular for big‑data processing, they are not a universal solution; tasks that are hard to partition or involve heavy cross‑node communication often perform better on a well‑optimized single machine, making a careful analysis of workload characteristics essential before scaling out.
Facing massive daily data volumes and complex, ad‑hoc analytical needs, Zhaozhuan’s engineering team evaluated multiple OLAP engines and chose ClickHouse, then built a four‑layer self‑service analytics platform, detailing architecture, use‑cases, performance tuning, large‑scale joins, and future roadmap challenges.
This article presents a comprehensive collection of MySQL optimization tips, covering everything from avoiding SELECT * and OR conditions to proper use of indexes, joins, UNION, batch operations, and query planning, each illustrated with clear examples and practical reasons for better performance.
This article examines why ClickHouse was chosen as the OLAP engine for a massive self‑service analytics platform, describes the system architecture, shares concrete memory and performance tuning parameters, and outlines current challenges and future roadmap for large‑scale real‑time data analysis.
The article explains that CPU spikes during Java deployments are caused mainly by HotSpot C2 JIT compiler threads, and demonstrates that tiered compilation, CodeCache sizing, JWarmUp pre‑warming, gradual traffic ramp‑up, and higher JIT compile thresholds together effectively smooth startup CPU usage.
This guide explains how to push a Kubernetes cluster toward its theoretical limit of 5,000 nodes by detailing official limits, master node sizing for GCE and AWS, kube‑apiserver high‑availability and connection‑count tuning, scheduler and controller‑manager leader election settings, kubelet optimizations, and DNS anti‑affinity configuration.
The article details how a Java team diagnosed frequent Full GC pauses caused by CMS, migrated to G1GC, adjusted JVM flags, scaled container specs, and achieved dramatically lower pause times, reduced instance counts, and significant cost savings while improving overall service stability.
This guide outlines Kafka stability best practices across three phases—pre‑prevention with tuning, producer/consumer guidelines, and cluster configuration; runtime monitoring using white‑box and black‑box metrics and alerts; and fault resolution strategies for backlogs, consumption blocks, and message loss, plus cost control and idempotence techniques.
A Sqoop job that normally finishes within 2.5 hours occasionally takes more than 8 hours due to data skew caused by an unsuitable split column, and the article details the investigation, root‑cause analysis, and a practical solution using a better split column and adjusted parallelism.
Xiaomi upgraded its Apache Doris from version 0.13 to the vectorized 1.1.2 release for its A/B experiment platform, conducting extensive single‑SQL and concurrent tests, identifying CPU, memory, and fragment timeout issues, and applying tuning such as memory decommit settings, string matching improvements, and patches to achieve up to 5× query speed gains and enhanced stability.
This article analyzes performance problems of a massive MySQL table, demonstrates how to use pt‑query‑digest and EXPLAIN to identify inefficient composite indexes, proposes index redesign, compares online DDL with pt‑osc for index rebuilding, and presents batch‑delete techniques to reduce SLA‑impacting latency.
The article details how Meituan’s Turing machine‑learning platform cut offline resource use by 80% and task time by 63% through memory‑level techniques such as column pruning, adaptive caching, and a deep dive into Spark’s mapPartitions operator, including source‑code analysis, GC behavior, and a low‑memory batch‑iterator best practice.
This article explains how JVM memory management and various garbage collection algorithms affect Spark task performance, covering JVM fundamentals, GC concepts, common collectors, and practical tuning strategies to avoid full GC pauses and improve throughput.
This article explains Spark's unified memory manager, detailing on‑heap and off‑heap memory regions, dynamic memory sharing, task memory allocation, and practical tuning techniques to optimize performance and avoid common out‑of‑memory errors.
This article outlines practical Spark job optimization techniques—from code-level improvements and resource tuning to data skew handling, persistence strategies, shuffle reduction, broadcast variables, Kryo serialization, and efficient data structures—demonstrating how each can dramatically cut execution time.
Explore comprehensive JVM performance optimization, covering memory architecture, key tuning flags, garbage collector selection, common OOM scenarios, and essential monitoring tools such as jstack, jstat, JConsole, and VisualVM, with practical examples and code snippets to help you diagnose and resolve memory issues.
This article explains how databases store data on various storage media, why indexes dramatically speed up queries through sorted structures and binary search, discusses different index types such as clustered indexes, and outlines common SQL optimization practices while warning against excessive indexing and typical pitfalls.
The article explains MySQL's continued dominance in the database market, presents recent developer survey statistics, describes its three‑layer logical architecture, and introduces the new edition of the "High Performance MySQL" book as a guide for modern database professionals.
This article provides an in‑depth explanation of the JVM memory model, detailing heap, method area, stacks, direct memory, various garbage‑collection algorithms, collector types, and common JVM tuning parameters for performance optimization.
This article shares practical Linux operations guidelines—including thorough testing, cautious use of destructive commands, strict backup policies, security hardening, continuous monitoring, performance tuning, and a disciplined mindset—to help avoid costly incidents and maintain stable production environments.
This article analyzes a large MySQL table with frequent SLA alerts, demonstrates how to identify slow queries using pt‑query‑digest, proposes index redesign and online DDL versus pt‑osc methods, and shows testing, implementation, and batch‑delete techniques to dramatically reduce query time and maintenance overhead.
Facing SLA alerts due to slow queries on a billion‑row MySQL table, the article analyzes slow‑query logs, reveals index misuse, and demonstrates how removing a poor composite index, adding targeted indexes, employing online DDL or pt‑osc, and using batch deletions dramatically reduce query times and maintenance overhead.
In this technical session, experts from Lingque Cloud and Yunshan Network discuss emerging cloud‑native networking trends through Kube‑OVN, demonstrate DeepFlow's full‑stack observability in Kube‑OVN environments, and answer a wide range of practical Q&A covering IP stability, underlay challenges, CNI support, and performance tuning.
A large‑scale user‑push system suffers from minutes‑long MySQL queries because the IN subquery materializes a temporary table and triggers a semi‑join that forces full table scans, but disabling the semi‑join optimizer or rewriting the query restores sub‑second performance.
After migrating a project to the MDP framework based on Spring Boot, the system repeatedly reported high swap usage despite a 4 GB heap configuration, leading to an investigation that uncovered native memory consumption caused by unchecked JAR scanning and allocator behavior, which was resolved by limiting scan paths and updating Spring Boot's inflater implementation.
This article explains how Redis stores key‑value pairs, details the internal data structures such as dict, dictEntry and redisObject, and provides practical memory‑saving tricks—including key shortening, encoding choices, object sharing, bitmap usage, hash consolidation, fragmentation handling, and 32‑bit deployment—to dramatically reduce RAM consumption while maintaining performance.
This article presents a comprehensive guide to optimizing Elasticsearch for massive datasets, covering Lucene fundamentals, index and shard architecture, practical performance‑tuning techniques, and real‑world case studies that achieve sub‑second query responses on billions of records.
This guide explores five essential dimensions of MySQL performance tuning—including connection configuration, architectural choices such as caching and read‑write splitting, optimizer settings, storage engine selection, and schema design—providing concrete commands, formulas, and best‑practice recommendations to accelerate query execution and reduce load.
This article explains Tomcat's component architecture, describes the request‑processing flow, and provides practical guidance on tuning the three critical parameters—maxThreads, maxConnections, and acceptCount—along with additional settings to improve backend service performance without additional hardware.
This article presents a detailed guide for optimizing large‑scale Apache Flink streaming jobs on the JD Real‑Time Computing platform, covering TaskManager memory model tuning, network stack configuration, RocksDB state management, checkpoint strategies, and additional performance tips with practical examples and calculations.
This guide presents Kube-OVN performance benchmarks, explains the testing environment and qperf commands, and provides step‑by‑step data‑plane optimization techniques—including CPU mode, NIC queue tuning, tuned profiles, interrupt binding, OVN LB disabling, FastPath module, OVS kernel compilation, and STT tunnel activation—to help administrators achieve lower latency and higher throughput in Kubernetes clusters.
When loading massive amounts of data into PostgreSQL, disabling autocommit, postponing index and foreign‑key creation, adjusting memory settings, using COPY or pg_bulkload, and fine‑tuning WAL and trigger settings can dramatically improve import speed and overall performance.
This article explains the JVM's Just‑In‑Time compilation mechanism and CodeCache memory area, detailing the purpose and default values of key JIT parameters such as TieredCompilation, CompileThreshold, OnStackReplacePercentage, CICompilerCount, as well as CodeCache settings like InitialCodeCacheSize, ReservedCodeCacheSize, Xmaxjitcodesize, CodeCacheMinimumFreeSpace and UseCodeCacheFlushing, and provides practical tuning advice for high‑traffic Java services.
This article explains how hardware architecture, Linux OS version, kernel configuration, OVS integration, memory management, NUMA awareness, and CPU micro‑architecture affect DPDK application performance and provides concrete tuning steps such as CPU isolation, service disabling, huge‑page setup, and optimized memory allocation.
This comprehensive guide explains Kafka’s origins, core architecture, data structures, write and read workflows, operational commands for topic and consumer‑group management, and practical performance‑tuning tips such as disk layout, JVM settings, flush policies, and log retention, providing a complete reference for engineers working with distributed streaming platforms.
This article describes Ctrip's adoption of Nebula Graph, covering the reasons for choosing the open‑source distributed graph database, its modular architecture, multi‑data‑center and blue‑green deployment patterns, middleware integration, client session management, query language extensions, and a series of performance‑tuning practices that solved stability and CPU issues in production.
This comprehensive guide examines why slow SQL queries degrade system performance, outlines key factors such as data volume, access patterns, and processing methods, and provides concrete optimization techniques, case studies, index design principles, and advanced features like MRR and index push‑down for MySQL‑InnoDB.
This article explains Tomcat’s internal component architecture, walks through the request‑processing flow, and details three crucial configuration parameters—maxThreads, maxConnections, and acceptCount—offering practical formulas and tuning guidelines to improve throughput without adding hardware.
This article explains how to identify and resolve performance bottlenecks in MySQL by locating slow queries, analyzing execution plans with EXPLAIN, focusing on type, rows and extra information, using profiling and trace tools, and applying practical optimization techniques illustrated through multiple real‑world cases.
This article details the design, deployment, and performance‑tuning techniques used by Tencent's TEG Data Platform to operate a massive Apache Pulsar cluster handling trillions of messages per day, covering server‑side parameters, client‑side configurations, common bottlenecks, and step‑by‑step troubleshooting advice.
The author recounts a chaotic typical day for Chinese operations engineers, then proposes a balanced schedule that prioritizes urgent firefighting tasks while dedicating most time to proactive monitoring, performance tuning, tool development, and continuous learning for long‑term system stability.
This article thoroughly examines Kafka's broker‑side network architecture, tracing its evolution from a simple sequential model to a high‑performance, event‑driven Reactor design using Java NIO, and provides practical tuning guidance for achieving optimal throughput and latency.
This article examines frequent MySQL performance problems—such as inefficient LIMIT usage, implicit type conversion, suboptimal joins, mixed ordering, EXISTS subqueries, condition pushdown limitations, early range reduction, and intermediate result handling—and provides concrete rewrites and execution‑plan analyses that dramatically improve query speed.
This article provides a detailed overview of Elasticsearch, covering its data model, Lucene foundation, cluster architecture, shard and replica mechanisms, index mapping, installation steps, health monitoring, write and storage processes, segment management, and performance tuning techniques for large‑scale search applications.
This article walks through a MySQL 5.6 scenario where a subquery that originally took over eight hours is accelerated by orders of magnitude through strategic index creation, query rewriting, and join optimization, illustrating the impact of single‑column, composite, and covering indexes on execution plans.
Youzan replaced ClickHouse and Druid with Apache Doris, refined its vectorized engine by eliminating deserialization overhead in the merge‑aggregation phase, achieving roughly a 30 % query‑time boost, and validated compatibility through SQL rewriting and traffic replay, while planning further SIMD‑based optimizations and broader adoption.
The team diagnosed intermittent Elasticsearch write‑timeout failures in their real‑time Flink‑to‑Elasticsearch pipeline as lock contention from frequent duplicate updates to the same document IDs, and eliminated the issue by aggregating binlog events in a 5‑second sliding window to deduplicate writes, adjusting refresh intervals, using async translog durability, and disabling non‑essential fields.
This article explains Redis's internal storage mechanisms and presents seven practical optimization techniques—including key‑value compression, small‑collection encoding, object sharing, bitmap usage, hash structuring, memory‑fragment defragmentation, and 32‑bit deployment—to dramatically reduce memory consumption while increasing data capacity.
The article investigates a MySQL 5.6 instance that consumed nearly all memory on a 32 GB test server, identifies misconfigurations, excessive MyISAM file handles, and severe memory fragmentation, and demonstrates how switching to tcmalloc reduced memory usage to a stable 5 GB.
Learn practical methods to boost server performance by selecting appropriate hardware configurations, analyzing CPU, memory, disk I/O and network loads, and fine‑tuning kernel parameters such as file limits and TCP settings, with step‑by‑step commands and monitoring tools like htop, iostat, and nload.
Drawing from three and a half years of DevOps experience, this guide compiles critical operational practices—ranging from cautious command execution and strict change control to robust backup, security hardening, continuous monitoring, performance tuning, and a disciplined mindset—to help engineers avoid costly outages and data loss.
This article thoroughly examines Kafka Broker's network architecture and request‑handling pipeline, exploring sequential, multi‑threaded, and Reactor‑based designs, detailing Acceptor and Processor threads, NIO mechanisms, and offering practical tuning tips to achieve high concurrency and performance.
This article walks through a real‑world case where a MySQL instance showed an abnormal 13 GB data_free value, explains how the ibtmp1 temporary tablespace caused the growth, demonstrates verification steps with sysbench and SQL queries, and provides configuration and operational solutions to prevent and resolve the issue.
This comprehensive guide explains what Nginx is, its advantages, typical use cases, request handling, high‑concurrency model, forward and reverse proxy concepts, directory layout, key configuration directives, load‑balancing algorithms, rate limiting, health checks, gzip compression, and practical examples for virtual hosts and module management.
This article outlines practical guidance for DBAs transitioning to Chinese domestic databases, highlighting why standard Oracle benchmark tweaks often fail, the limited relevance of buffer‑hit ratios, the importance of SQL execution efficiency, and specific strategies for handling high‑concurrency workloads.
This article explains MySQL's internal execution process—including the connector, cache, parser, optimizer, and executor—describes privilege tables and verification, discusses query caching removal, outlines logical SQL execution order, and provides practical tips for ordering WHERE conditions to improve performance.
This article provides a detailed guide on optimizing MySQL performance, covering SQL statement tuning, index usage, table design normalization, system configuration, hardware choices, and the internal architecture of MySQL to help developers write faster and more efficient queries.
This article explores the various reasons MySQL queries become slow—including index misuse, insufficient connection pools, small InnoDB buffer pools, and query cache limitations—while providing practical solutions such as optimizing indexes, adjusting max_connections, enlarging buffer pools, and configuring connection pools for better performance.
The article details a real‑world case where JVM C2 CompilerThread CPU spikes during service startup caused request timeouts and GC pressure, explains how profiling identified the JIT compilation as the root cause, and describes a warm‑up replay strategy that pre‑compiles hotspot code to eliminate the spikes and stabilize deployments.
This article presents a systematic overview of eight practical database optimization techniques—including data reduction, serialization, archiving, intermediate tables, sharding, distributed caching, master‑slave replication, and appropriate storage selection—to help backend engineers diagnose and resolve the majority of performance bottlenecks caused by data volume, high load, and search complexity.
NetEase’s senior big‑data engineer shares how the company’s large‑scale data platform leverages Hadoop, HDFS, YARN and related technologies, detailing multi‑layer architecture, cross‑cloud deployment, storage optimizations, NameNode performance enhancements, RPC prioritization, and practical lessons from operating petabyte‑scale clusters.
This article explains why databases become slow, introduces a four‑layer thinking model, and presents eight practical solutions—including reducing data volume, leveraging space for performance, and selecting the right storage system—to help backend engineers resolve 80‑90% of common performance problems.
This article walks through generating a heavy‑load MySQL workload, using top, iostat, and iotop to pinpoint high disk I/O, mapping OS thread IDs back to MySQL sessions, and safely killing the offending query to relieve pressure.
This article analyzes MySQL batch insertion performance, explains how row size, max_allowed_packet, buffer pool, transaction handling, and index design affect throughput, and presents empirical tests that suggest using roughly half of the max_allowed_packet size as the optimal batch size for large data loads.
This guide explains why mini‑programs need load testing, outlines three common testing scenarios, describes four test‑type designs, and provides step‑by‑step instructions for using Alibaba Cloud PTS to obtain platform tokens, configure APIs, and run stable, long‑duration pressure tests.
This article provides a comprehensive overview of ClickHouse, covering its core use cases, detailed explanations of the various table engines, recommended schema and deployment patterns, performance‑tuning parameters, tooling choices, and operational guidelines for building and maintaining high‑availability OLAP clusters.
This article explains why databases become slow, introduces a four‑layer thinking model, and presents eight practical optimization techniques—including data reduction, caching, sharding, master‑slave replication, and CQRS—along with their benefits, drawbacks, and suitable scenarios.
This article demonstrates how a MySQL pagination query on a 9.5‑million‑row table that originally took over 16 seconds can be accelerated to under 0.4 seconds by moving the LIMIT condition into a subquery that selects only primary‑key IDs and then joining to retrieve the remaining columns, with detailed code and experimental verification.
This comprehensive guide covers MySQL fundamentals including the three normal forms, permission tables, ACID properties, index design principles, SQL statement categories, sharding, deadlock resolution, isolation anomalies, view characteristics, SQL lifecycle, primary key choices, performance troubleshooting, replication, GTID, backup tools, and backup planning.
A single Aerospike node experienced extreme XDR replication lag due to a misconfigured forward setting, and the article walks through terminology, monitoring data, root‑cause analysis, and step‑by‑step commands to resolve the issue and improve cluster performance.
This article examines common reasons why MySQL queries become slow, including index misuse, insufficient connections, and small InnoDB buffer pools, and provides practical solutions such as profiling, using EXPLAIN, adjusting connection limits, and tuning buffer pool size.
This comprehensive guide explores MySQL's architecture, explains how indexes work, details the use of EXPLAIN to analyze query execution, and provides practical optimization strategies—including index creation, avoiding common pitfalls, and improving single- and multi-table queries—to dramatically boost database performance.
This article outlines a systematic approach to identifying and fixing slow MySQL queries, explains how to interpret EXPLAIN output and profiling information, and presents multiple real‑world cases illustrating index usage, implicit conversion, large pagination, IN queries, and other optimization techniques.
This article explains how Tencent Cloud's APM metric calculation, which transforms massive Span data into aggregated metrics using Flink, faced performance bottlenecks and was optimized through job splitting, batch merging, and dimension pruning, ultimately achieving a 2‑3× speed increase and cutting resource usage to about 30% of the original.
This article walks through essential Elasticsearch node‑level APIs—covering how to retrieve basic node info, detailed statistics, thread‑pool usage, and hot‑thread diagnostics—complete with request examples, response samples, and practical tips for diagnosing common cluster issues.
This article provides an in‑depth overview of Kafka, covering why messaging systems are needed, core concepts, cluster architecture, performance optimizations such as sequential disk writes and zero‑copy, hardware sizing, replication, consumer groups, offset management, rebalance strategies, and practical deployment and operational guidelines.
This article provides a thorough step‑by‑step guide to identify why Redis latency spikes, covering baseline performance testing, slowlog analysis, big‑key handling, expiration patterns, memory limits, fork overhead, huge pages, AOF settings, CPU binding, swap usage, memory fragmentation, network bandwidth, and practical optimization techniques.
This article provides a comprehensive guide to MySQL performance improvement, covering pagination, index, join, sorting, UNION, slow‑query‑log, schema design, and hardware optimizations with concrete SQL examples, best‑practice tips, and cautionary notes for real‑world deployments.
The article explains how Apache Hudi automatically manages file sizes to avoid small‑file issues, details key configuration parameters, provides a step‑by‑step example of file merging, and offers practical Spark tuning recommendations for optimal performance in data‑lake workloads.
This guide explains Linux performance optimization by defining core metrics such as throughput, latency, and average load, describing how to select and benchmark indicators, outlining essential analysis tools like vmstat, pidstat, and perf, and providing practical CPU and memory tuning strategies to eliminate bottlenecks.
This guide provides a comprehensive overview of ClickHouse, covering its core use cases, detailed table‑engine choices, cluster design, Zookeeper integration, query and data‑loading best practices, client tools, and key configuration parameters to ensure high performance and reliability in OLAP workloads.
This article describes a performance bottleneck in a high‑traffic search service, details the investigation of hardware limits, long‑tail query impact, load‑testing methodology, and the subsequent optimizations—including SSD upgrade, data‑structure reduction, and Elasticsearch segment tuning—that reduced disk I/O and improved throughput.
This comprehensive guide explains Elasticsearch’s core concepts—including its distributed architecture, indexing process, shard routing, refresh and translog mechanisms, segment merging, and performance tuning—while providing practical examples and configuration tips for building scalable, near‑real‑time search solutions.
This guide outlines practical Linux server optimization techniques—from disabling unnecessary daemons and GUI to tuning kernel parameters, file systems, TCP settings, and monitoring tools—helping administrators boost stability, reduce resource usage, and improve overall system performance.
The article shares a senior engineer’s practical experience on combining open‑source and self‑developed components, analysing their advantages, lifecycle stages, and concrete strategies—including problem definition, selection, source‑code control, and ten actionable tips—to help teams balance cost, innovation, and stability.
This article investigates how the innodb_ddl_threads, innodb_ddl_buffer_size, and innodb_parallel_read_threads variables introduced in MySQL 8.0.27 affect parallel DDL execution speed and resource consumption, using a 50‑million‑row test table and presenting detailed benchmark results.
This article, part of a series analyzing Serverless platforms for Spring Boot, explains how to diagnose and reduce cold‑start latency, covering tracing, reserved instances, lazy initialization, JVM options, and instance concurrency tuning, using the high‑traffic Mall demo application as a concrete example.
This comprehensive guide explores Go performance optimization techniques, covering pprof profiling, trace analysis, GODEBUG diagnostics, and escape analysis, while providing practical code examples and real‑world case studies to help developers identify and resolve CPU, memory, and goroutine bottlenecks in production services.
This guide walks through setting up Sentry Relay on your own hardware using Docker, covering recommended deployment patterns, system requirements, configuration options, performance tuning, request routing, and monitoring to securely forward events to sentry.io.
This article provides an in‑depth guide to Spark performance optimization, covering the ten development principles, static and unified memory models, resource parameter tuning, data skew detection and mitigation techniques, as well as shuffle‑related configuration adjustments, supplemented with practical code examples and diagrams.
This article introduces several MySQL performance‑diagnostic utilities—including mysqltuner.pl, tuning‑primer.sh, pt‑variable‑advisor, and pt‑query‑digest—explains how to download and run them, and shows how to interpret their reports for optimizing database configuration and query performance.
The article details three Xianyu backend incidents where Full GC pauses caused latency spikes or outages, analyzes root causes ranging from survivor space shortage and mis‑tuned CMS to oversized async Log4j events and massive string‑concatenation logs, and presents remediation steps such as switching to G1GC, adjusting Log4j settings, and using parameterized logging to eliminate the pauses.
The article explores MySQL's Hash Join algorithms, comparing Basic, On-disk, Grace, and Hybrid variants, while detailing rule-based optimizer decisions, memory management, disk spilling mechanisms, and outer join execution strategies through source code analysis.
Over a month we reduced Full GC occurrences from around 40 times per day to roughly one every ten days by systematically adjusting JVM parameters, addressing memory leaks, and fine‑tuning metaspace and young generation settings, ultimately achieving lower GC pause times and higher server throughput.
This article explains the four locations where java.lang.OutOfMemoryError can occur in Hadoop's MapReduce framework—client, ApplicationMaster, Map, and Reduce phases—and provides configuration adjustments and best‑practice solutions to mitigate each type of OOM issue.
This comprehensive guide explains the JVM memory model, details each memory region, compares major garbage‑collection algorithms, and lists essential JVM tuning parameters for optimal Java performance.
This article provides a thorough introduction to Redis, covering its core data structures and common commands, persistence options (RDB and AOF), memory‑management and eviction policies, pipelining, transactions and Lua scripting, performance optimization techniques, replication, Sentinel high‑availability, cluster sharding, and a comparison of popular Java clients.
This article details Ctrip's migration from MySQL to TiDB, describing the multi‑data‑center architecture, real‑world use cases such as the international CDP platform and hotel settlement, performance tuning measures, comprehensive monitoring and alerting, auxiliary tools, and future roadmap for the distributed NewSQL database.
