This article explains why bit manipulation is a staple technique in computer science, detailing performance gains, state flag encoding, mask operations, data compression, cryptography, image processing, hash structures, binary counting, and algorithm design, with practical Go examples.
iLogtail, a lightweight log collector, has transformed over 13 years from a simple log‑gathering tool into a full‑stack, cloud‑native observability platform, introducing Go plugins, high‑performance C++ pipelines, SPL processing, modular architecture, and advanced self‑monitoring, reflecting broader trends in data collection technology.
This article walks through evaluating massive MySQL tables, explains why large row counts slow queries, and compares three practical solutions—table partitioning, database sharding, and hot/cold archiving—while highlighting their trade‑offs and offering guidance on selecting the right approach for a given workload.
This article details the end‑to‑end architecture, rate‑limiting strategies, caching layers, database optimizations, and hardware upgrades that enabled a lottery service to handle daily traffic exceeding one million users during peak promotional events.
The article explains why executing a full‑table UPDATE on large MySQL tables using row‑based binlog can overload replication, discusses the inefficiencies of deep pagination and IN clauses, and presents a batch‑processing strategy that leverages SQL_NO_CACHE and FORCE INDEX to safely and efficiently migrate data.
This article details a step‑by‑step performance improvement journey for a category‑tree query in a SpringBoot‑Thymeleaf system, covering Redis caching, scheduled jobs, local Caffeine cache, Gzip compression, and data slimming with byte‑array storage to resolve latency and large‑key issues.
This article walks through five successive performance optimizations—adding Redis caching, scheduling async updates, introducing a Caffeine local cache, enabling Nginx GZip compression, and compressing Redis data—to dramatically reduce the size and latency of a category‑tree API in a SpringBoot application.
This document defines comprehensive C language coding standards covering clarity, simplicity, testability, safety, efficiency, and portability, offering concrete principles, rules, and suggestions to guide developers in writing maintainable, reliable, and high‑performance code.
This article explains why JVM tuning is essential for performance, outlines a step‑by‑step optimization workflow—including GC monitoring, heap dumps, parameter tuning, and tool usage—provides a concrete Java code example that triggers memory pressure, and shares effective JVM flags to prevent out‑of‑memory errors.
This article explains why a simple full‑table UPDATE on massive MySQL tables can cripple master‑slave replication, analyzes deep‑pagination inefficiencies, and presents a step‑by‑step batch‑update strategy using NO_CACHE and FORCE INDEX to keep binlog size and buffer‑pool impact under control.
This article explains how to implement pagination, multi‑condition fuzzy search, and their combination using Redis Sorted Sets and Hashes, discusses performance optimizations and expiration strategies, and also contains promotional material for ChatGPT services and a community offering.
This article explains how to apply Simon Sinek's Golden Circle framework to migrate a large‑scale Webpack‑based frontend project to Vite, detailing the motivations, the faster development experience, step‑by‑step migration procedures, configuration adjustments, and the resulting performance improvements.
Training deep learning models on a thousand GPUs faces steep communication overhead, higher failure probability, and scaling inefficiencies, but by profiling each step, overlapping compute and communication, using gradient bucketing and accumulation, and employing elastic training techniques, practitioners can approach near‑linear performance while mitigating common pitfalls.
This article explains how JD adopted the Taro cross‑platform framework to build HarmonyOS native applications, detailing the background, technical方案, key features, performance results, and future optimization plans for delivering high‑performance mobile experiences.
The article details JD's adoption of the Taro cross‑platform framework to build a HarmonyOS native app, describing the technical architecture, CSS and rendering optimizations, performance gains over native ArkTS, and future plans for further speed and flexibility improvements.
By redesigning the caching layer with a two‑level architecture combining local and distributed caches, the author dramatically reduced CPU usage, lowered response times, and increased system capacity under high QPS workloads, while evaluating trade‑offs of various cache strategies, pre‑warming, refresh mechanisms, and operational considerations.
This article explains Java's escape analysis, covering method, thread, and non-escape scenarios, and shows how the JIT compiler can reduce heap allocation, remove unnecessary synchronization, and apply scalar replacement to improve performance.
By leveraging Redis sorted sets for ordered pagination and hash fields with HSCAN for multi‑condition fuzzy matching, the article shows how to build a cached query pipeline that creates temporary ZSets keyed by pattern, supports efficient page retrieval, and uses expirations and refresh strategies to balance freshness and performance.
This article explains what swap space is, why it matters for system stability and performance, and provides detailed Linux commands and procedures for creating, configuring, activating, and monitoring swap files or partitions.
The article examines why eBPF has become a core building block for cloud‑native network functions, outlines its performance, security and flexibility advantages, discusses technical challenges such as memory constraints and missing SIMD support, and presents the eNetSTL library that mitigates these issues with concrete design details and benchmark results.
This article explains the challenges of executing full‑table UPDATE statements on large MySQL tables using row‑based binlog replication, analyzes deep pagination issues, and presents a batch‑processing strategy with FORCE INDEX, SQL_NO_CACHE and controlled rate limiting to safely migrate data at scale.
This article details Tencent Game's end‑to‑end approach to building intelligent NPCs, covering the opportunities brought by AI, the practical implementation of multimodal LLM‑driven dialogue, knowledge‑augmented retrieval, long‑context handling, safety measures, multimodal expression (voice and facial animation), and system‑level performance optimizations for real‑time deployment.
The article chronicles the time wheel algorithm from its 1997 origins, explains simple, round‑based, and hierarchical wheel designs, compares them to queue timers, details Dubbo’s HashedWheelTimer implementation, and shows how combining the wheel with a delay‑message queue can dramatically improve service scalability and efficiency.
This article explains the challenges of scaling large AI models, introduces PaddlePaddle 3.0's four‑dimensional hybrid parallelism and its unified automatic parallel framework, details core concepts such as ProcessMesh and Placements, provides step‑by‑step code examples, and outlines performance‑optimizing strategies like operator fusion and pipeline scheduling.
The article examines the role of various locks in Linux kernel memory management, explains their APIs and sleeping constraints, presents detailed case studies of lock‑related performance patches—including per‑memcg LRU, mmap_lock IO‑fault path, SPF, PVL, fault‑around, unmap, and rmap lockless optimizations—and summarizes common strategies for reducing lock contention and improving scalability.
This article explains the core concepts of connection‑pool technology, details the architectural choices behind HikariCP such as dual HikariPool instances, FastList, custom ConcurrentBag, ThreadLocal caching, and byte‑code generation, and walks through the key source code that makes the pool exceptionally fast.
This article recounts a developer's journey from a fresh graduate to a senior backend engineer, detailing two real‑world incidents—a pseudo‑memory‑leak in a C++ service and a uint overflow that caused traffic bursts—showing the analysis steps, code fixes, and lessons learned for reliable backend development.
This article outlines nine practical methods—caching, parallelization, batch processing, data compression, lock‑free design, sharding, request avoidance, pooling, and asynchronous handling—demonstrating how each can be applied to backend services to dramatically reduce latency and improve throughput.
This article explains how to use React's Context API to implement elegant multi‑theme switching, avoid props drilling, manage multiple contexts, and apply memoization techniques to prevent unnecessary re‑renders, improving performance and maintainability.
This article shares Xiaomi's experience building a next‑generation one‑stop data development platform on Spark 3.1, covering typical challenges such as Multiple Catalog implementation, Hive‑SQL to Spark‑SQL migration, offline Spark performance and stability optimizations, and future roadmap plans.
This course provides an in‑depth exploration of integrating Swoole with Laravel to create and manage a database connection pool, covering fundamental concepts, integration steps, performance optimization, real‑world case studies, and best practices for both Laravel and Swoole developers.
This article details Shanghai Jiao Tong University's design and deployment of the nation’s first campus‑level high‑performance computing cluster based on Huawei Kunpeng 920 ARM processors, covering background, user challenges, unified storage, network topology, containerized software delivery, and performance validation with LAMMPS and GATK.
This article provides a comprehensive overview of Nginx, covering its high‑performance architecture, module types and functions, master‑worker process model, asynchronous non‑blocking I/O mechanisms, FastCGI and PHP‑FPM integration, as well as detailed configuration and optimization techniques for production deployments.
This article explains the concepts of resource loading, preloading, lazy loading, conditional and batch loading in PHP, and provides detailed guidance on using autoloading mechanisms such as __autoload(), spl_autoload_register(), PSR‑4, and Composer to improve performance and maintainability of backend applications.
This article explains how MySQL's Buffer Pool caches data in memory, its default size and configuration, the internal structure of instances, chunks, control blocks and pages, and how it manages data loading, dirty pages, and flushing to disk for optimal query performance.
This article details the end‑to‑end migration of ByteDance's HTTPDNS service from a central cloud to edge nodes, covering technical challenges in service placement and traffic scheduling, the edge‑native solutions implemented with visualization models and GTM, and the resulting performance, cost and reliability gains.
This article presents ten practical Python performance optimization techniques—including using generators, built‑in libraries, local variables, list comprehensions, efficient string joining, reducing loop work, multithreading/multiprocessing, JIT compilation, and profiling—to help developers write faster, more efficient code.
This article details how Tencent Music’s data‑infrastructure team migrated thousands of ClickHouse and Druid nodes to a StarRocks compute‑storage‑separated lakehouse, achieving 40‑50% cost reduction while maintaining query performance, and shares the technical challenges, solutions, and best‑practice recommendations gathered during the process.
The article outlines nine broadly applicable techniques—caching, parallel and batch processing, data compression, lock‑free design, sharding, eliminating unnecessary requests, and resource pooling—that together can dramatically cut service latency and improve throughput, as demonstrated by an 80% latency reduction in a real‑world project.
The paper presents SsdEngine, a hierarchical SSD‑based advertising retrieval cache that combines a thread‑local ART cache with a lock‑free central array, uses flying pointer‑swizzling to cut duplicate I/O, and evaluates eviction policies (LRU, DoubleClock, TinyLFU, ARC), showing LRU excels under Zipfian locality while TinyLFU improves small‑cache hit rates.
This article introduces a new book 'Deep Understanding of Linux Processes and Memory' that systematically explains CPU, memory, and process scheduling principles, covering hardware fundamentals, virtual memory, Golang coroutines, container resource management, and performance optimization techniques.
Facing a 600k/min rate‑limit alert on a game’s product‑update MQ, the team analyzed scattered consumers, designed a new Flyweight‑Strategy architecture with Spring AOP idempotency, executed a three‑phase migration, and achieved a 50‑80% reduction in downstream interface calls.
The article details Dewu’s custom Flink scheduler, DwScheduler, which adds JSON‑based resource specifications, per‑TaskManager slot sharing for balanced CPU use, hot TaskManager migration callbacks, and a new TmRestart strategy for rapid pod‑process recovery, offering practical techniques to enhance real‑time stream processing stability and performance.
The article recounts Tencent PCG’s journey from concept to a fully managed, customer‑centric search platform XSearch—detailing its evolution as a middle‑platform product, performance‑and‑cost‑optimized architecture, flexible functional design, streamlined R&D and operations processes, comprehensive documentation, and long‑term strategic outlook.
This article translates and analyzes the MegaScale system—co‑developed by ByteDance and Peking University—that enables efficient, stable training of massive language models on clusters of more than 10,000 GPUs, achieving 55.2% MFU and a 1.34× speedup over Megatron‑LM.
This article describes how a legacy Vue2‑based cloud management system was profiled with Lighthouse and webpack‑bundle‑analyzer, then optimized through static asset compression, dead‑code removal, tree‑shaking, code‑splitting, async loading and server tweaks, achieving a three‑fold reduction in bundle size and a 13.6‑second improvement in first‑contentful‑paint time.
The article examines the new characteristics, challenges, and technical practices of intelligent computing platforms required for large‑model AI workloads, covering infrastructure adaptation, heterogeneous scheduling, application acceleration, operation reliability, and future directions for simplifying GPU usage and connecting heterogeneous resources.
This article explains how to configure Docker and Containerd to use domestic image‑mirror services, providing detailed commands and verification steps that dramatically reduce image‑pull latency and improve development and operations efficiency in cloud‑native environments.
This article examines why a scalar subquery in an OceanBase 3.2.3.3 SQL statement takes over 1000 seconds, breaks down the execution plan, identifies the costly nested-loop behavior, and presents a rewrite using WITH and LEFT JOIN that reduces the cost from 788 million to 3.6 million and cuts runtime to about 10 seconds.
This case study details how Qunar’s engineering team analyzed and resolved severe Kafka production bottlenecks during peak traffic by adding targeted monitoring, tuning thread and filebeat parameters, and validating changes through gray‑scale tests, ultimately saving 2000 CPU cores across three clusters.
This tutorial explains how to boost Laravel application performance by leveraging Laravel Telescope for detailed monitoring, optimizing the queue system with Redis and worker scaling, and deploying Laravel Octane with Swoole to efficiently handle high‑traffic loads.
Java thread pools efficiently manage and reuse threads by applying a producer‑consumer model, transitioning through RUNNING, SHUTDOWN, STOP, and TERMINATED states, handling task queues, and employing configurable rejection policies such as Abort, CallerRuns, Discard, and DiscardOldest, while improving performance, resource utilization, and stability across web servers, asynchronous processing, and other concurrent workloads, distinct from connection pools which manage database connections.
By splitting the main.dart.js bundle with deferred components, serving CanvasKit assets and Google fonts from a private CDN, and optionally using the HTML renderer during development, Flutter Web apps can cut their startup time by five to six seconds, achieving sub‑second load performance.
This article provides a comprehensive guide to backend caching, covering fundamental concepts, usage scenarios, read‑through and cache‑aside strategies, local and distributed cache types, popular services like Redis and Memcached, eviction algorithms such as FIFO, LRU, LFU, and common issues like consistency, avalanche, penetration, and stampede, along with practical mitigation techniques.
This article explains how to improve PHP application performance by implementing a data caching class, illustrates a weather‑API example, shows how to set cache duration, avoid duplicate data storage, and discusses production considerations such as concurrency, large data, security, and expiration handling.
This article details a month‑long investigation and step‑by‑step tuning of a Java server's JVM parameters, memory‑leak fixes, and metaspace adjustments that reduced FullGC from dozens of times daily to a single occurrence every ten days while improving overall throughput.
This article demonstrates how to insert 300,000 rows into a MySQL table using MyBatis and JDBC, compares direct batch insertion, row‑by‑row insertion, and optimized batch strategies, and provides performance measurements and practical tips for efficient large‑scale data loading.
Blaze is Kuaishou's self‑developed native execution engine that leverages Rust, DataFusion, and SIMD vectorization to accelerate Spark workloads, offering a 30%+ compute boost, detailed architectural components, deep production‑grade optimizations, and a roadmap for broader adoption.
This article explores the two‑stage LLM inference pipeline, introduces TTFT and TPOT metrics, explains the motivation for prefilling‑decoding separation, presents experimental comparisons between split and merged architectures, and details optimization techniques and parallel‑strategy modeling for DistServe.
This article presents a real‑world case of optimizing a high‑concurrency transaction‑statistics API, detailing diagnosis of a 30‑second latency, SQL refactoring with array_agg and unnest, Java‑level improvements, and Caffeine caching, while also sharing promotional offers for ChatGPT services and a developer community.
This article demonstrates how to insert 300,000 rows into a MySQL table efficiently by defining a User entity, configuring MyBatis and JDBC, comparing direct batch insertion, row‑by‑row insertion, and optimized batch strategies with configurable batch sizes and wait times, and provides performance results and best‑practice recommendations.
This article presents nine comprehensive performance‑optimization strategies—including load balancing, sharding, read/write separation, caching, indexing, CDN, asynchronous processing, code refinement, and algorithm improvement—aimed at boosting the efficiency and scalability of large‑scale backend systems.
This article presents a comprehensive technical overview of using ClickHouse as a native backend to accelerate Spark SQL execution, covering Spark performance bottlenecks, ClickHouse's CPU‑level optimizations, the design and implementation of the Spark‑Native integration, and detailed TPC‑DS benchmark results demonstrating up to 3.5× speedup.
This case study details how the AiFenxi business intelligence platform integrated Apache APISIX as a high‑performance API gateway within Tencent Cloud TKE, addressing latency, scalability, and security challenges, and outlines the architectural changes, deployment steps, and resulting performance improvements.
This article presents a detailed technical overview of accelerating Spark's compute engine using ClickHouse as a native backend, covering Spark performance background, ClickHouse's advantages, the design and implementation of a Spark‑Native acceleration solution, and extensive performance evaluation results.
The article examines PHP’s rise to the 15th spot in the TIOBE June index, analyzing its deep web roots, mature frameworks, performance gains, vibrant community, and integration with modern technologies like Docker and front‑end frameworks, while also discussing future challenges such as scalability, type safety, and cloud‑native adoption.
This article details Meituan's production‑grade adoption of Spark vectorized execution via the open‑source Gluten and Velox stack, explaining SIMD fundamentals, performance motivations, the end‑to‑end integration workflow, staged rollout, encountered challenges, and the resulting resource savings and speedups.
Meituan enhances Apache Spark by integrating the Gluten‑Velox vectorized execution engine, converting row‑wise operations to columnar SIMD processing, which yields over 40 % memory savings and up to 13 % faster runtimes across thousands of ETL jobs, while addressing stability, ORC support, shuffle redesign, and off‑heap memory optimization.
This article explains why CPU caches are needed, describes the hierarchy and internal structure of L1, L2, and L3 caches, compares direct‑mapped, set‑associative and fully‑associative designs, and shows how cache‑aware coding (row‑major vs column‑major loops) dramatically improves execution speed.
This article describes how a unified membership system serving billions of users across multiple platforms achieves high performance and high availability through dual‑center Elasticsearch clusters, traffic isolation, deep ES optimizations, Redis caching, dual‑center MySQL partitioning, seamless migration, and fine‑grained flow‑control and degradation strategies.
This article explores common performance bottlenecks of WebView and H5 pages in mobile apps and presents a comprehensive set of optimization strategies—including preloading, rendering tweaks, network enhancements, and memory management—to achieve near‑instant page loads and improve overall user experience.
The article examines how the shift to Software‑Defined Vehicles introduces complex performance engineering challenges across software, hardware, and organizational domains, and proposes an engineering‑driven, continuous‑observability approach—including modeling, monitoring, iterative optimization, and specialized team structures—to sustainably improve automotive software performance.
This article presents JD Logistics' one‑stop agile BI platform, detailing the complex data sources, rapid business demands, the UData solution architecture, performance and usability improvements, and future upgrade plans that together enable faster data integration, self‑service reporting, and enhanced decision‑making across the organization.
This article details how the WeChat team leverages ClickHouse at massive scale, introduces a suite of performance observation tools, describes lakehouse reading and bitmap optimizations, and explains the integration of AI workloads, demonstrating overall query speedups of up to tenfold across diverse scenarios.
This article explores fundamental PHP caching techniques—including OPcache, HTTP header client caching, Memcached/Redis object caching, reverse‑proxy page caching, dynamic content caching, and cache invalidation—providing code examples and practical guidance to help developers dramatically improve application performance and scalability.
The article examines performance bottlenecks in marketing systems when filtering blacklisted accounts, proposes multithreaded processing and bitmap-based set operations—including Java BitSet and RoaringBitmap—to dramatically reduce processing time from tens of minutes to milliseconds, and discusses implementation details, memory efficiency, and broader applications such as indexing and Redis.
This article details Mobile QQ's 20‑year evolution, the overwhelming technical debt that made its monolithic architecture unsustainable, and the multi‑stage decoupling, refactoring, and NT architecture upgrades that dramatically improved modularity, performance, development efficiency, and user experience across all platforms.
This guide explains how to deploy RabbitMQ on Kubernetes and improve its performance through Helm installation, resource tuning, monitoring, scaling, security hardening, and advanced configuration techniques, providing practical code examples for each step.
This article explains how virtual scrolling can dramatically improve the performance of large online document editors by rendering only visible content, discusses various implementation strategies such as progressive pagination, canvas rendering, line‑ and block‑level virtualization, and details state management, view‑locking, fast‑scroll handling, and integration scenarios like anchor navigation, find‑replace, and comment systems, while providing code examples and performance test results.
By migrating the CatEar FM live‑streaming app’s WebSocket layer to Chromium’s Cronet network stack, the team unified cross‑platform code, added customizable DNS and proxy support, and cut handshake latency by roughly 150 ms on Android and 250 ms on iOS, paving the way for future HTTP/2 and HTTP/3‑based WebSocket transports.
This article details the product models, usage scenarios, and a series of performance and operational optimizations—including query plan health checks, space reclamation, resource isolation, cloud‑native deployment, cross‑region high availability, and unified monitoring—implemented for the TiDB service operated by 360 Zhihui Cloud since its launch in April 2023.
This article presents a comprehensive case study of Zhihu's Bridge platform, detailing its background, five core modules, unified architecture built on Spark and Flink, bitmap‑based tagging, and performance optimizations that address query speed, write latency, and high‑QPS online checks while outlining future directions with Doris 2.0 and large language models.
The article explains what constitutes an SQL problem, presents a typical case of performance degradation caused by mismatched character sets, and outlines how the SQLE platform can help developers, testers, and DBAs systematically manage and improve SQL quality throughout the software lifecycle.
The article examines Linux 6.1’s preemption mechanism, explaining latency sources, the three preemption configurations (none, voluntary, full), the TIF_NEED_RESCHED flag and preempt_count tracking, and how preempt_enable/disable affect real‑time responsiveness, illustrated by a case where RT threads cannot preempt CFS due to disabled preemption in critical driver code.
The article explains how NCCL’s collective communication libraries enable efficient large‑scale model training by parsing GPU‑to‑NIC topology, forming flat‑ring and tree rings, improving logging and bandwidth metrics, detailing Ring AllReduce primitives, and proposing solutions to missing topology, metric, and mapping information for future optimization.
This article demonstrates how to build a high‑performance data processing engine using PHP and SOAP by setting up a SOAP server, creating a client, and applying optimization techniques such as efficient function design, caching, asynchronous processing, and database tuning.
This article explains how to reduce server load and improve performance of Go applications on Kubernetes by using lightweight base images, fine‑tuning resource limits, adjusting garbage‑collection settings, employing connection pools, configuring health probes, and leveraging autoscaling, load balancing, and caching techniques.
The article introduces Archer, a new big‑data warehouse engine built on Iceberg that adds an inverted‑index mechanism using Tantivy to provide full‑text and JSON search, storage‑compute separation, and significant performance gains over traditional Elasticsearch and Iceberg connectors.
This article explains why Mini Programs are popular, describes their dual‑thread architecture, and provides concrete strategies—including reducing call frequency, limiting data volume, and applying data layering and rendering chunking—to optimize setData performance and improve user experience.
This article details how Alluxio was adopted to replace NAS in autonomous driving model training, describing the data closed‑loop workflow, the challenges of the previous system, Alluxio's architectural benefits, deployment strategies across single and multiple data centers, functional and performance testing, operational tuning, and the resulting cost and efficiency gains.
This article explains the fundamentals of caching, enumerates various client‑side, server‑side and distributed cache types, describes common caching patterns and expiration policies, and highlights practical considerations to effectively improve web application performance and reliability.
This article describes how 58.com designed and implemented a large‑scale user profiling platform using ClickHouse, covering system overview, core modules, major challenges of scale, complexity and performance, and the detailed storage, query, and optimization techniques applied to meet business needs.
This article presents a comprehensive log governance and mining solution for distributed systems, covering background challenges, usage scenarios, and detailed strategies such as distributed log integration, front‑back end traceability, standardized log management, large‑payload handling, efficient cleaning, and future plans for componentization and sampling.
This article explains how a data‑driven approach to code reduction—measuring function usage, weighting functions, and prioritizing deletions—enabled a large‑scale backend coupon system to cut code‑review effort by up to 40%, improve readability, and manage the high risks of refactoring.
This article explains the CPU cache locality principle, shows how to restructure Go data access patterns—including data structures, field ordering, memory allocation, and false sharing avoidance—and demonstrates measurable performance gains with a matrix‑multiplication benchmark.
Java developers must master performance optimization by using tools like Skywalking and Arthas, which leverage Java agents, class-loading and bytecode manipulation (via ByteBuddy/ByteKit) to locate bottlenecks, filter data with OGNL, and fine-tune interface response times in real-time.
This article documents how a team reduced the average deployment time of the omega application from 229 seconds to 69.71 seconds—a 69% speed‑up—by analyzing startup logs, removing unused middleware, upgrading libraries, fixing logging configurations, and applying async bean creation and script optimizations.
This article details a series of Kafka message backlog incidents in a busy restaurant ordering system, analyzes root causes such as consumer speed, database indexing, and sudden traffic spikes, and presents step‑by‑step optimizations—including batch queries, index tuning, data archiving, and thread‑pool adjustments—to restore real‑time performance.
Spring 6.2 introduces asynchronous bean initialization, a new addSingletonCallback mechanism, global transaction rollback settings, and injection performance optimizations, eliminating blocking during multi‑threaded event publishing and dramatically reducing startup time, as demonstrated with code examples and performance test results.
Manbang Group scaled its digital freight platform by replacing self‑built Eureka and ZooKeeper clusters with Alibaba Cloud MSE Nacos and ZooKeeper, achieving seamless traffic migration, dramatic performance gains, and high‑availability features such as push‑empty protection and incremental pull for Eureka clients.
