This article presents a comprehensive benchmark comparing memcached and ScyllaDB across memory, disk, and read‑only workloads, analyzes architectural trade‑offs, and offers practical guidance on when to prefer a simple in‑memory cache versus a persistent wide‑column database.
This extensive series of 50 video lessons covers fundamental and advanced topics such as technology selection, capacity planning, micro‑service design, database scaling, caching strategies, load balancing, decoupling, layering, and service mesh, providing engineers with the knowledge needed to become proficient architects.
The article details how designing a two‑level cache architecture—combining local and distributed caches—dramatically reduced CPU usage, response time, and improved system capacity under high QPS workloads in a Kubernetes‑based container environment, while evaluating trade‑offs of several caching strategies.
This article defines high concurrency, outlines QPS thresholds for small, medium, high, and ultra‑high traffic, and presents practical solutions such as multi‑level caching, load balancing, database sharding, and message‑queue traffic shaping to build robust backend systems.
This article explains how to speed up PHP database interactions by using persistent connections, implementing a connection pool, and caching query results, providing code examples for mysqli, PDO, and Memcached, and discusses when each technique is appropriate for improving backend performance.
This article analyzes the challenges Ctrip faced when handling massive traffic during ticket flash‑sale events and details the architectural upgrades, caching strategies, database optimizations, supplier integration safeguards, and traffic‑control mechanisms that enabled stable, fast, and consistent booking experiences.
This article explains Python decorators, covering their definition as higher‑order functions, essential concepts like closures, step‑by‑step examples of basic, parameterized, class‑based, and stateful decorators, as well as practical uses such as logging and caching, all illustrated with clear code snippets.
This article explains how the 360 media gateway supports various video sources, performs real‑time protocol conversion, uses caching and RingBuffer for efficient stream management, and demonstrates its high‑concurrency capabilities through extensive stress and latency tests.
This article explains why stale JavaScript can break functionality, outlines the risks of caching such as outdated bugs, security flaws, and debugging difficulties, and provides practical Java‑side solutions—including versioned URLs, cache‑control headers, static‑resource policies, and ETag/Last‑Modified handling—to ensure browsers always load the latest scripts.
Tencent Meeting optimized its “My Recordings” list by replacing offset pagination with cursor‑based seeks, implementing a two‑layer cache separating ID lists from record details, choosing MongoDB for multi‑source aggregation, and adding reliable Kafka‑driven sync, cutting latency from 308 ms to 70 ms while supporting over 700 QPS.
This article analyzes the performance differences between native Java reflection and Spring Framework's ReflectionUtils by running benchmark tests, examining source code caching mechanisms, and explaining why ReflectionUtils can be faster for repeated method and field access in backend applications.
This article demonstrates how to create various parameterized decorators in Python—including logging, performance measurement, authentication, caching, and file logging—by providing clear explanations and complete code examples for each use case in practical applications.
This article outlines a series of backend interface performance optimization strategies—including batch processing, asynchronous execution, caching, preprocessing, pooling, parallelization, indexing, transaction management, program structure refactoring, deep pagination, SQL tuning, and lock granularity—to help developers reduce latency and improve system efficiency.
This article analyzes Java performance bottlenecks and demonstrates how to use CompletableFuture for parallelism, fine‑tune ThreadPoolExecutor parameters, minimize transaction scope, apply cache‑line padding, object pooling, lock‑granularity techniques, copy‑on‑write collections, and reduce network payloads to achieve lower latency and higher throughput.
This guide explains how to enable and fine‑tune NGINX Plus content caching, covering cache zones, key definitions, loader settings, cache bypass, purge configuration, byte‑range slicing, and practical examples for optimizing performance and reducing backend load.
This guide walks you through installing Squid on Linux, configuring caching, ACLs, and network settings, troubleshooting startup issues, and testing the proxy to improve bandwidth usage and enforce access control for your internal users.
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.
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 guide explains Redis's eight memory eviction policies, their algorithms, ideal scenarios, and step‑by‑step configuration via redis.conf, CONFIG SET, or command‑line options, helping you choose the right strategy to balance performance, data safety, and resource limits.
To accelerate PHP database operations, the article explains how to use persistent connections with mysqli or PDO, implement a connection pool via a custom class, and cache query results using Memcached or Redis, detailing code examples for each technique.
Optimizing database performance is crucial for PHP applications, and this comprehensive guide explores advanced strategies—including efficient query design, indexing, caching, connection pooling, batch processing, sharding, and partitioning—to maximize speed, scalability, and user experience while reducing latency and server load.
The article explains what high concurrency means, defines TPS thresholds for moderate, high, and ultra‑high traffic, and outlines key backend techniques such as distributed and microservice architectures, caching, load balancing, traffic shaping, and rate‑limiting/circuit‑breaking to handle massive request volumes.
Front‑end development transforms a URL request into a rendered page by downloading HTML, CSS, and JavaScript, building the DOM and CSSOM, executing scripts, constructing a render tree, then performing layout and paint, while modern workflows use component frameworks, build tools for bundling and minification, versioned or hashed assets with long‑term CDN caching, and non‑overlapping gray‑release deployments to ensure smooth updates.
This article walks through using JetCache with Spring Boot 3.2.5, covering its features, Maven dependency setup, YAML configuration, annotation-based caching, programmatic cache creation, statistics monitoring, and deprecated APIs, all illustrated with code snippets and screenshots.
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 comprehensive guide walks backend architects through six core optimization methods—caching, batch processing, asynchronous handling, data compression, parallelization, and eliminating unnecessary requests—detailing their problem domains, implementation strategies, real‑world scenarios, benefits, and trade‑offs.
This article explains how ZuanZuan calculates and displays expected delivery times, outlines the system architecture across order, OMS, WMS, and TMS modules, and describes caching and high‑concurrency techniques used to support millions of delivery‑time queries per second.
This article provides a comprehensive guide to improving Java backend performance by explaining parallel processing with CompletableFuture, minimizing transaction scope, effective caching strategies, proper thread‑pool configuration, cache‑line alignment, reducing object creation, lock granularity, copy‑on‑write collections, asynchronous patterns, loop optimizations, network payload reduction, and minimizing inter‑service dependencies.
This article introduces Python decorators—such as retry, timeout, logging, caching, response validation, parameterization, exception handling, performance monitoring, permission checking, and composite usage—and provides complete code examples showing how they simplify and strengthen automated API testing.
This article explains how to build high‑concurrency systems by decomposing monoliths into micro‑services, employing caching and message queues, separating databases, using read‑write splitting, and applying business‑level traffic shaping to achieve performance and availability.
This article analyzes real‑world search query characteristics, breaks down a typical search system architecture, classifies cacheable data, compares result‑level, intermediate‑value and multi‑layer caches, discusses update, prefetch and placement strategies, and highlights common pitfalls such as cache miss, consistency, and resource overhead.
This article explains Redis persistence mechanisms (RDB and AOF), common caching challenges such as avalanche and penetration with mitigation techniques, outlines Redis data types and their use cases, compares cluster solutions, and details replication, transactions, and distributed locking strategies.
This article outlines nine practical methods—caching, parallel processing, batch handling, data compression, lock‑free design, sharding, request avoidance, pooling, and asynchronous processing—illustrated with Redis, MySQL, Go, and Kafka examples, showing how they collectively cut latency and improve throughput.
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 explores how PostgreSQL’s advanced features—UNLOGGED tables, JSONB, SKIP LOCKED, TimescaleDB, pg_cron, PostGIS, full‑text search, JSON generation, pgaudit, and GraphQL adapters—can replace specialized tools like Kafka, Redis, MongoDB, and others, simplifying the tech stack while boosting performance and maintainability.
This article explains the importance of caching, compares common replacement policies, and walks through a complete Go implementation of a thread‑safe local LRU cache, including interface design, data structures, linked‑list management, and concurrency handling.
This article explains how to use Workbox to simplify Service Worker development, covering installation via CLI or CDN, core concepts like caching strategies, route matching, and custom handlers, and provides practical code examples to improve offline support and performance for web applications.
This article explains how to build high‑concurrency systems by analyzing hardware and code optimizations on a single machine, exploring multi‑machine scaling, database and business‑application considerations, and presenting a practical inventory‑stock case that evolves from simple locking to partitioned, asynchronous, Redis‑based designs.
This article examines the necessity of caching in ad‑search workloads, evaluates classic eviction policies such as LRU, LFU, Redis Approx‑LRU, OS PageCache, DoubleClock, ARC, 2Q, TinyLFU, and presents a layered TLS‑centered cache design (SsdEngine) with detailed benchmark results showing hit‑rate and latency improvements across Zipfian and uniform workloads.
Facing tight schedules and diverse coding habits, many Chinese projects struggle with API latency; this guide walks through requirement analysis, acceptance standards, common pitfalls, and a comprehensive set of optimization tactics—from configuration and code tweaks to caching, async processing, and observability tools—to dramatically improve API performance.
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.
This article presents a thorough collection of practical techniques for optimizing backend interface performance, covering index management, SQL tuning, parallel remote calls, asynchronous processing, transaction handling, lock granularity, caching strategies, sharding, and monitoring tools, offering actionable guidance for developers to improve service efficiency.
This article presents a real‑world case study of a high‑concurrency data‑processing interface whose response time was reduced from 30 seconds to under one second by diagnosing SQL bottlenecks, refactoring MyBatis code, applying PostgreSQL array aggregation, and introducing a Caffeine cache, while also discussing the limits of relational databases and promoting related AI services.
This comprehensive guide explains how to boost WordPress site speed and SEO by applying PHP‑based strategies such as query optimization, regular database maintenance, custom tables, option‑table tuning, indexing, and caching, complete with practical code examples.
This article details a multi‑level caching architecture—spanning CDN, Nginx, Redis, JVM cache, and MySQL—that dramatically speeds up product information access in e‑commerce systems while enhancing reliability and scalability.
This article presents a real‑world case study of a high‑concurrency transaction‑statistics API that originally took 30 seconds to respond, detailing problem diagnosis, SQL and Java code analysis, and a series of optimizations—including SQL rewrites, database‑side calculations, and Caffeine caching—that ultimately brought the response time below one second.
Redis, an open-source in-memory NoSQL database, is explored in depth covering its high-performance features, typical use cases, evolution, architecture, data types and commands, followed by an overview of Tencent Cloud Redis services and a brief advertisement for a DevOps certification program.
This comprehensive guide explains hardware, frontend, and backend optimization techniques—including server upgrades, CDN usage, code minification, caching strategies, and database tuning—to systematically improve website speed and maintain high performance.
This article presents Xiaohongshu's multi‑cloud unified data acceleration layer built with Alluxio, detailing the challenges of multi‑cloud architectures, the design goals, Alluxio's architecture and features, real‑world case studies in AI training and recommendation indexing, performance improvements, and future plans.
The article outlines practical backend interface performance optimizations—including proper indexing, SQL tuning, parallel remote calls, batch queries, asynchronous processing, scoped transactions, fine-grained locking, pagination batching, multi-level caching, sharding, and monitoring tools—to dramatically reduce latency and improve throughput.
The article examines why internet architectures have become increasingly complex, explains the unique challenges of flash‑sale (秒杀) business scenarios, and presents practical backend optimization techniques such as request filtering, Redis caching with atomic operations, ordered queues, data‑layer safeguards, and unit‑based isolation for global deployments.
This comprehensive guide walks backend developers through practical techniques—such as proper indexing, SQL refactoring, parallel remote calls, asynchronous processing, caching layers, sharding, and monitoring—to diagnose and dramatically improve API response times and overall system throughput.
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 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 details Uber's Docstore distributed database challenges and explains the design, architecture, and implementation of CacheFront—a transparent, high‑performance caching layer that reduces latency, improves scalability, and maintains strong consistency across microservices.
This article walks through practical Java backend performance techniques—including parallel processing with CompletableFuture, fine‑tuned thread‑pool configuration, transaction scope minimization, cache‑line awareness, object‑pool usage, lock granularity, copy‑on‑write collections, and network payload reduction—backed by concrete code samples, benchmark results, and step‑by‑step analysis of trade‑offs and best practices.
This guide walks backend developers through twenty real‑world Redis use cases—from basic caching, lotteries, and like/collect features to ranking, PV/UV counting, Bloom filters, sign‑in, geo‑search, rate limiting, ID generation, distributed locks, messaging, session sharing, and more—providing Spring Boot code samples, limitations, and best‑practice advice.
The article explains how to use FreeType to load and render font glyphs into bitmaps, upload those bitmaps as OpenGL textures, render them with texture coordinates, and employ a bitmap cache and fixed‑size texture atlas to efficiently manage and reuse character images in a fast double‑buffered text rendering pipeline.
An in‑depth guide to backend caching covers read‑through and cache‑aside strategies, local versus distributed caches (including Redis and Memcached), eviction algorithms such as FIFO, LRU and LFU, and tackles consistency, avalanche, penetration and breakdown issues with practical mitigation techniques.
This article examines how enabling and tuning OPcache can dramatically boost PHP request throughput, presents benchmark results before and after optimization, discusses configuration trade‑offs, and outlines safe deployment and cache‑clearing strategies for high‑traffic backend systems.
This article explains the HTTP QUERY method—a safe, idempotent request type that carries query payloads in the body, contrasts it with GET and POST, details caching behavior, the Accept-Query header, and provides practical examples of direct and indirect responses.
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.
This article presents a comprehensive, step‑by‑step guide to building large‑scale backend systems—including microservice decomposition, CDN and cache layers, message queues, database sharding, read/write splitting, Elasticsearch search, distributed transaction handling, multithreaded data migration, and massive counting services—illustrated with real‑world examples and practical metrics.
This article outlines seven typical cache problems—including cache penetration, breakdown, avalanche, large keys, hot keys, hit‑rate issues, and data inconsistency—and provides practical solutions such as parameter validation, Bloom filters, null‑value caching, locking, auto‑renewal, random expiration, high‑availability setups, compression, and cache warming to improve system reliability and performance.
This article analyzes the challenges of high‑concurrency environments and presents a comprehensive solution that includes rights verification and issuance processes, cost‑service trade‑offs, three‑high guarantees, rate‑limiting methods, multi‑level caching, request merging, inventory splitting, and isolation techniques to ensure system stability and scalability.
This article details how ICBU's core communication pages were accelerated by applying HTTP chunked transfer, streaming HTML rendering, Nginx tweaks, ThreadLocal handling, and caching strategies, resulting in FCP dropping from 2.6 s to 1.9 s and LCP from 2.8 s to 2 s.
This article explores five advanced JavaScript techniques—Monads, declarative programming, server‑side caching, immutability, and pattern matching—explaining their concepts, benefits, and providing practical code examples to help senior developers build more robust, high‑performance web applications.
This article introduces Ehcache, an open‑source Java local‑cache framework, explains its layered storage options, flexible expiration policies, eviction strategies, and provides comprehensive code examples for configuring in‑memory, off‑heap, and disk‑persistent caches, along with practical usage tips and performance considerations.
This article explains how to design an effective multi‑level cache architecture for microservice systems, covering client‑side browser caching, CDN and Nginx static resource caching, application‑layer in‑process caches, distributed Redis caches, and strategies for maintaining cache consistency using message queues.
This article explains Python descriptors and decorators, detailing their protocols, differences, and use cases such as attribute validation, logging, permission control, caching, and parameter validation with illustrative code examples in real-world scenarios.
This article outlines a comprehensive backend architecture for community platforms and billion‑level e‑commerce systems, covering microservice decomposition, DDD modeling, caching strategies, Redis clustering, message‑queue decoupling, database sharding, read‑write separation, distributed transaction approaches, multithreaded data migration, and massive counting techniques.
This article explains the essential conditions, metrics, and scenario classifications for building high‑concurrency systems, then details common solutions such as database read/write separation, local and distributed caching, cache‑eviction policies, handling master‑slave lag, preventing cache penetration and avalanche, and applying CQRS to achieve scalable, high‑performance back‑end services.
This article explains the essential elements of high‑concurrency system design—performance, availability, scalability—introduces quantitative metrics, classifies read‑heavy and write‑heavy scenarios, and details practical solutions such as database read/write separation, local and distributed caching, cache‑penetration and avalanche mitigation, and CQRS implementation for billion‑user applications.
The article humorously chronicles a series of real‑world over‑design incidents—excessive microservice splitting, needless multi‑database sharding, ubiquitous message‑queue usage, over‑engineered caching, design‑pattern abuse, and bloated database schemas—highlighting why simplicity (KISS) remains the best practice for backend systems.
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 explains various server‑side caching strategies—including full‑page static caching, fragment caching, data and query caching, time‑based and content‑change invalidation, as well as memory caches like Memcached and Redis, Apache modules, APC, and opcode caches—providing PHP code examples for each method.
This article explains Python decorators, covering their definition as higher‑order functions, basic syntax, practical examples such as logging, authorization, caching, and nested decorators, and demonstrates how they enhance code modularity, readability, and reusability without altering original functions.
This article analyzes feed‑timeline architectures, compares pull‑based and push‑based models, proposes an online‑push/offline‑pull hybrid, and details practical implementations using Redis SortedSets, multi‑level caching with Cassandra, cursor‑based pagination, and large‑scale push task sharding.
This article explains the fundamentals of HTTP caching, including how it works, the different cache types, key cache-control directives, and the testing scenarios where testers must be aware of cache behavior to ensure performance, data consistency, and security.
This article explains Python decorators, covering their purpose and providing ten practical examples—including timing, logging, caching, type checking, singleton, retry, profiling, authentication, asynchronous, and input validation—each illustrated with complete, ready‑to‑run code snippets.
This article outlines a comprehensive set of high‑concurrency strategies—including caching, rate limiting, circuit breaking, asynchronous processing, pooling, code optimization, JVM tuning, horizontal scaling, warm‑up, data heterogeneity, and sharding—applied to the Baige traffic platform to handle tens of thousands of QPS during peak loads.
The article walks through MyBatis’s internal execution pipeline, from loading the configuration file and building a SqlSessionFactory, to creating a SqlSession, generating a MapperProxy for the mapper interface, and finally invoking the mapped method which triggers JDBC operations, while detailing caching and executor mechanisms.
This article explains how using an off‑heap local cache (OHC) can dramatically lower GC pauses and cut interface latency by up to tenfold, covering the underlying principles, configuration, custom serializers, performance testing, monitoring metrics, and practical optimization recommendations for high‑traffic Java backend services.
This article explains how to build a multi‑level caching system for microservice applications, covering client‑side HTTP caching, CDN and Nginx static‑resource caching, in‑process and distributed Redis caches, consistency challenges, and practical guidelines for when such a design is beneficial.
This comprehensive guide explores the complexities of building enterprise‑level Retrieval‑Augmented Generation (RAG) systems, detailing common failure points, architectural components such as authentication, input guards, query rewriting, document ingestion, indexing, storage, retrieval, generation, observability, caching, and multi‑tenant considerations, and provides actionable best‑practice recommendations for developers and technical leaders.
This article explains why Spring MVC cannot parse multiple @RequestBody annotations on a single handler method, analyzes the internal I/O stream closure that causes the failure, and provides a practical solution using a request‑body caching wrapper and a servlet filter to allow repeated reads of the request payload.
This tutorial walks through configuring Spring Cloud OpenFeign with Spring Boot, covering basic setup, advanced capabilities like Micrometer metrics, Redis caching, @SpringQueryMap, @MatrixVariable, and @CollectionFormat, and shows how to view metrics via Prometheus or Actuator.
Learn practical ways to enhance a system’s concurrent handling capacity, including traffic distribution via load balancers, database sharding and clustering, message queues, caching layers, CDNs, code and database optimizations, and scaling hardware resources such as servers, CPUs, and memory.
This article provides a comprehensive introduction to Redis, covering its core features, supported data types, common caching use cases in Spring Boot, typical cache‑related problems such as consistency, avalanche, penetration and breakdown, as well as performance reasons, eviction policies, persistence mechanisms, master‑slave replication, and Sentinel high‑availability architecture.
Cache Aside is a popular caching pattern that reads from cache first and writes through the database before invalidating the cache, but concurrent read‑write scenarios can cause stale data; the article explains these pitfalls and recommends the double‑delete strategy to keep cache and database consistent.
This article explains why Nginx is renowned for high performance and details the architectural components—master and worker processes, event‑driven non‑blocking I/O, memory pooling, load‑balancing, caching, modular design, and proxy mechanisms—that enable it to sustain millions of simultaneous connections.
This article explains why performance optimization is essential for growing systems, introduces key metrics such as response time and concurrency, outlines systematic thinking and concrete techniques—including caching, parallelism, and async processing—and demonstrates a live‑streaming case study with actionable solutions.
This guide explains why batch processing is essential for API tuning and provides step‑by‑step techniques—including bulk database operations, request merging, pagination, parallel execution, caching, and monitoring—backed by concrete Java code samples and SQL queries to help engineers dramatically improve throughput and latency.
This article explores sixteen practical Redis patterns—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, message queues, lotteries, likes, tags, filtering, follow relationships, and ranking—demonstrating how each can boost performance and simplify backend architecture.
This article provides an in‑depth overview of Redis, covering its core concepts, data structures, performance characteristics, persistence mechanisms, high‑availability solutions, clustering, cache design patterns, operational best practices, and underlying implementation details for developers and architects.
This comprehensive guide covers high‑performance development techniques—including I/O optimization, zero‑copy, multiplexing, concurrency, thread‑pool design, lock‑free programming, inter‑process communication, RPC, serialization, database indexing, caching strategies, Bloom filters, full‑text search, and load balancing—to help developers build fast, scalable, and reliable systems.
This article explains how to design an effective multi‑level caching system in microservice environments, covering client‑side browser caching, application‑layer static resource caching with CDNs and Nginx, and service‑layer caches using in‑process solutions and distributed Redis, while also addressing consistency and deployment considerations.
This article summarizes the typical causes of slow backend interfaces—such as MySQL slow queries, complex business logic, thread‑pool misconfiguration, lock contention and machine‑level problems—and provides concrete optimization techniques, code examples, and best‑practice recommendations for Java services.
This comprehensive guide outlines practical Redis best practices covering memory optimization, key design, data type selection, performance enhancements, high‑availability deployment, operational safeguards, security hardening, and monitoring to help engineers build stable, efficient caching solutions.
Redis is widely known as a high‑performance cache, but its rich data structures, persistence options, and distributed features enable it to serve as a primary storage engine for many internet services, from user profiles and leaderboards to rate limiting, messaging, and geo‑location, while presenting scalability and reliability challenges.
