A benchmark of Redis, Memcached, DragonflyDB, and Cashews using the same FastAPI workload reveals that Redis falls behind on latency, throughput, and memory efficiency, while DragonflyDB and Cashews offer superior performance and developer experience for Python caching.
Learn how to accelerate PHP database operations by employing persistent connections, implementing a connection pool, and caching query results, with clear code examples for mysqli, PDO, and Memcached that illustrate each optimization technique and its impact on reducing latency and resource usage.
A $6 DigitalOcean server handling millions of requests survived a Hacker News surge by visualizing traffic, distinguishing bots from real users, and deploying tiny gzip‑compressed zip bombs that explode malicious crawlers' memory, demonstrating low‑cost operations and security tactics for resilient web services.
This article explains the various PHP caching layers—including OPcode, data, page, and HTTP caching—provides configuration examples, code snippets for file, Memcached, and Redis caches, and outlines best practices and invalidation strategies to improve web application performance.
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 article compares Memcached, Redis, and Aerospike across persistence, replication, performance, memory management, and use‑case scenarios to help you select the most suitable in‑memory database for high‑throughput, low‑latency applications.
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 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 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 why PHP caching is essential for web performance and details three main techniques—page caching with output buffering, data caching using extensions like Memcached or APCu, and file caching with file I/O functions—plus best practices for updates, expiration, and avoiding cache penetration.
This article explains the core design goals, sharding strategies, replication models, communication protocols, cache selection, and monitoring techniques needed to build high‑performance, highly available, and scalable distributed cache systems for large‑scale internet applications.
This article provides a comprehensive overview of Redis, covering its common application scenarios, detailed comparisons with Memcached, internal data structures, implementation details, and practical usage patterns such as caching, leaderboards, counters, and real‑time analytics for modern backend systems.
This article explains Memcached’s architecture, key characteristics, suitable and unsuitable scenarios, memory management and LRU mechanisms, version details, and provides a comprehensive guide to monitoring its performance and health using Prometheus and Alibaba Cloud ARMS dashboards.
This guide explains why Nginx proxying to an HTTP backend causes the browser URL to change, how to fix the redirect by using HTTPS, and how to achieve session consistency across multiple Tomcat instances by integrating Memcached for shared session storage.
Memcached 1.6.18 has been released, bringing extensive fixes and enhancements to the proxy mode, extstore disk flushing, meta‑protocol changes, and numerous core and backend improvements, including signal handling, thread naming, Lua debugging, and clang‑15 build compatibility.
This article explains why an Nginx reverse‑proxy configuration that proxies HTTPS requests to a backend server causes the browser URL to change, how to fix the redirect by using HTTPS in the proxy, and how to achieve session consistency across multiple Tomcat instances by deploying Memcached with Docker and adjusting Tomcat’s session manager.
The article explains why interviewers probe the implementation details of backend components such as Redis, HashMap, and Memcached, illustrates common interview questions, and shows how mastering the underlying data structures, algorithms, and memory‑allocation mechanisms can improve both interview performance and real‑world problem solving.
This guide explains caching fundamentals, purposes, and optimal use cases, details hit rates and eviction policies such as FIFO, LRU, LFU, TTL/TTI, compares client‑side (HTTP, browser) and server‑side caches (CDN, Redis, Memcached), explores multi‑level architectures, common pitfalls like avalanche, penetration and breakdown, and best‑practice strategies including pre‑warming, update patterns, and consistency management.
This article examines the characteristics of Redis and Memcached, identifies typical design mistakes such as consistency, cache avalanche, hot‑key, penetration and breakdown issues, and presents practical mitigation strategies—including consistent hashing, binlog‑driven cache invalidation, distributed locking, and multi‑node replication—to help backend engineers build reliable high‑concurrency cache layers.
This article compares Redis, Memcached, and MongoDB, outlining each system's strengths and weaknesses, performance characteristics, storage capabilities, availability, reliability, consistency, data analysis features, and typical application scenarios to help developers choose the appropriate NoSQL solution.
This article examines the characteristics of Redis and Memcached as distributed cache solutions, outlines common design pitfalls such as consistency, cache penetration, breakdown, avalanche, and hot‑key issues, and provides practical strategies—including consistent hashing, binlog‑driven invalidation, message‑queue indexing, and lock mechanisms—to build reliable and high‑performance caching layers in backend systems.
This article provides a comprehensive overview of caching in large distributed systems, covering theory, common components, classification, CDN and reverse‑proxy caches, local application caches, popular implementations like Ehcache, Guava, Memcached and Redis, and a detailed comparison of their features and trade‑offs.
This article provides a comprehensive overview of caching in large‑scale distributed systems, covering cache fundamentals, classification, major implementations such as CDN, reverse‑proxy, local, and distributed caches, detailed analyses of Memcached and Redis, common design challenges, and real‑world industry solutions.
This article provides an in‑depth technical overview of how Pinterest scales its distributed cache layer using Memcached and Mcrouter on AWS, covering architecture, performance, high availability, load balancing, trade‑offs, and future directions.
This article compares Redis and Memcached across thread model, data structures, eviction policies, pipelining, persistence, high availability, and clustering, helping developers choose the most suitable in‑memory database for their specific performance and feature requirements.
This article explains the concept of gray (canary) releases, walks through installing Nginx with Lua and memcached modules, shows how to configure Nginx to route traffic based on client IP stored in memcached, and provides testing steps to verify the rollout.
This article analyzes the characteristics of Redis and Memcached, explains typical design mistakes such as inconsistent hashing, cache avalanche, penetration, and hot‑key issues, and provides practical solutions like consistent hashing, binlog‑driven cache invalidation, key versioning, and distributed locking to improve cache reliability and performance.
This article systematically compares Redis and Memcached across thread models, supported data structures, eviction strategies, pipelining, transactions, persistence, high‑availability mechanisms, and clustering, helping developers choose the most suitable in‑memory database for their specific workload requirements.
This article compares Redis and Memcached across thread models, data structures, eviction policies, pipelines, persistence, high availability, and clustering, helping developers choose the most suitable in‑memory database for their specific workload and performance requirements.
This article systematically compares Redis and Memcached across thread models, data structures, eviction policies, pipelining and transactions, persistence, high availability, and clustering, helping developers choose the most suitable in‑memory database for their specific business requirements.
This article explains the MySQL Memcached API, its evolution from MySQL 5.6 to 8.0, demonstrates how to install the plugin, configure tables, and perform batch and range key retrievals with code examples, highlighting suitable use cases and performance benefits.
This article compares Memcached and Redis, covering their installation, shared features such as sub‑millisecond latency and language support, and key differences in data structures, persistence, replication, transactions, pub/sub, geospatial commands, scripting, and memory efficiency to help you choose the right cache solution.
This tutorial walks through creating a lightweight Memcached client in Node.js, covering cluster routing with consistent hashing, low‑level TCP communication, a reusable connection‑pool implementation, and a custom protocol for get operations, complete with practical code examples.
This article explains what Redis is, how it is used for caching in projects, the performance and concurrency advantages of caching, common cache pitfalls, key differences between Redis and Memcached, and the internal single‑threaded event‑driven architecture that enables high‑throughput operations.
This article compares Redis and Memcached across network I/O models, supported data structures, memory management mechanisms, persistence options, consistency guarantees, and clustering approaches, highlighting the strengths and trade‑offs of each in‑memory data store.
Redis and Memcached differ significantly in data structure support, memory efficiency, performance, memory management, persistence options, and clustering capabilities, with Redis offering richer data types, server‑side operations, configurable persistence, and native clustering, while Memcached provides simpler key‑value storage, slab allocation, and client‑side distribution.
This article explains Nginx's web caching concepts, covering the 404‑error‑driven and resource‑not‑found caching mechanisms, their configuration, limitations, and how memcached can be used for key/value caching to improve server performance and reliability.
This article explains various PHP caching techniques—including full‑page static generation, partial page fragments, data and query caching, time‑based and content‑change strategies, as well as memory caches like Memcached, Apache cache settings, APC extension, and opcode caching—providing code examples and practical guidance to improve web performance.
This article explains what cache hit rate is, how to monitor it in Memcached and Redis, the key factors that influence it, and practical strategies for architects to improve hit rates and overall application performance.
This article details Meitu's engineering of a Redis/Memcached proxy platform, describing why twemproxy was chosen, the limitations of its upstream version, the multi‑process redesign with live configuration reload, added latency metrics, reuse‑port handling, Redis master‑slave support, performance testing, and remaining challenges.
The article details Meitu's adaptation of Twitter's twemproxy into a multi‑process, hot‑reloading, high‑availability Redis/Memcached proxy, describing its architecture, custom features, performance testing, remaining challenges, and open‑source resources for other engineering teams.
This article provides a comprehensive overview of caching in large distributed systems, covering CDN, reverse‑proxy, local and distributed caches, popular implementations such as Ehcache, Guava, Memcached and Redis, common pitfalls like consistency and avalanche, and practical solutions with real‑world case studies.
This article explains why distributed caching is essential for high‑concurrency systems, outlines typical use cases, compares Memcached and Redis across features and performance, and discusses common problems such as cache avalanche, penetration, warm‑up, update strategies, and degradation.
Learn how to install libevent, compile and set up Memcached on Linux, start the service with common options, monitor it via telnet, interpret detailed statistics, and use basic Memcached commands, all with clear command examples and parameter explanations.
This article presents a detailed failure analysis of a memcached service outage, explaining how the XMemcached client uses consistent hashing and heartbeat mechanisms to manage sessions, the impact of server loss on request latency, and the verification steps and solution to reduce session timeout and improve recovery.
This article compares the three most common distributed cache solutions—Redis, Memcached, and Alibaba's Tair—across nine technical dimensions, then dives into Redis fundamentals, high‑availability setups with Sentinel, and cluster sharding to help engineers make informed cache‑selection decisions.
Memcached reflection DDoS attacks have surged, breaking terabit‑per‑second records with peaks of 1.35 Tbps and 1.94 Tbps, prompting warnings from Cloudflare and Arbor, targeting online services worldwide, while Tencent Cloud’s Zeus Shield mitigated the traffic and experts advise stronger UDP monitoring, high‑capacity defenses, and regular simulations.
This article explains the fundamentals of caching, why it is essential for high‑traffic web services, compares cache components such as Memcached and Redis, and details design patterns, scalability, high‑availability, and operational practices for building robust distributed cache systems.
Redis and Memcached are compared across network I/O models, supported data structures, memory management, persistence, consistency, and clustering, revealing Redis’s richer feature set and flexibility while highlighting Memcached’s simplicity and speed, helping developers choose the right in‑memory solution for their workloads.
This article details a comprehensive robustness test of a core public service system's caching layer, exposing how decreasing Memcached (MC) instances dramatically impacts TPS and latency, analyzes the underlying Ketama consistent‑hash algorithm, and proposes concrete improvements to mitigate such failures.
This article compares Redis and Memcached across data‑type support, memory management, persistence mechanisms, and clustering features, highlighting their architectural differences, performance trade‑offs, and suitable use‑cases to help developers choose the right in‑memory storage solution.
This article provides a comprehensive technical comparison between Redis and Memcached, covering server‑side operations, memory efficiency, performance characteristics, supported data types, memory management mechanisms, persistence options, and clustering architectures, illustrated with diagrams and concrete command examples.
This article explains the fundamental concepts behind Nginx web caching, covering the proxy‑store and resource‑not‑found mechanisms, configuration examples, and how memcached can be integrated to efficiently store and retrieve cached responses, improving performance and resilience.
The article surveys cache fundamentals—request flow, hit rates, eviction policies, and media—then compares local versus distributed caches and reviews concrete implementations such as programmatic caches, Ehcache, Guava, memcached, and Redis, before detailing Spring’s annotation‑driven caching and a Meituan case study on custom annotation caches.
This article compares Memcached and Redis, evaluating their architectures, performance, scalability, persistence, and suitable use cases for handling tens of millions of database rows with high‑speed caching and in‑memory data storage.
This article examines the MySQL‑Memcached architecture, explains Memcached’s slab memory management, compares Redis and Memcached across performance, memory efficiency, persistence and data structures, details Redis’s core data types and their internal implementations, and showcases practical use‑cases such as caching, ranking, queues, Pub/Sub and real‑time analytics.
This guide walks through the fundamentals, installation steps, configuration details, and Python integration for three essential backend services—Memcached for high‑performance caching, Redis for persistent key‑value storage, and RabbitMQ for reliable messaging—complete with command‑line examples, code snippets, and best‑practice tips.
This article explains Memcached’s slab allocator mechanism—including items, chunks, slab classes, and pages—how memory is allocated, fragmented, and evicted, and then explores master‑slave double‑layer architectures, high‑concurrency challenges, and scaling strategies such as L1 caching for robust, high‑availability deployments.
This article provides a detailed comparison of Memcached and Redis by examining their service models, event loops, memory allocation strategies, database structures, persistence mechanisms (RDB and AOF), transaction support, and publish‑subscribe features, highlighting the design choices, trade‑offs, and implementation nuances of each key‑value caching system.
A multi‑person technical discussion explores the reasons behind low cache hit rates, examines memcached LRU mechanisms, proposes AOP‑based caching strategies, and shares practical solutions such as proactive cache invalidation, lock‑based stampede protection, and workload‑aware configuration for backend systems.
This article explains how memcached’s client‑side distribution works, illustrates the role of consistent hashing in assigning keys to servers, compares traditional modulo hashing with consistent hashing, discusses hash function choices, and provides complete Java and Python implementations for a scalable distributed cache.
This article compares Redis and Memcached across data‑type support, memory‑usage efficiency, performance, memory‑management mechanisms, persistence options, and clustering capabilities, highlighting the strengths and trade‑offs of each in‑memory data store.
This article explains Memcached's slab allocator memory management, key concepts like items, chunks, and pages, illustrates allocation and eviction processes, and discusses high‑availability architectures such as master‑slave and L1 caching layers for scalable distributed systems.
This article explains the fundamentals of caching, the role of distributed caches like memcached in high‑concurrency environments, and details the algorithms—including remainder hashing and consistent hashing with virtual nodes—that enable memcached to distribute data across multiple servers efficiently.
This article explains the fundamentals of caching, the role of memcached in high‑concurrency environments, and details the distributed implementation methods such as remainder hashing and consistent hashing, including their advantages, drawbacks, and optimization techniques.
This article explains the three common cache problems—penetration, concurrency, and expiration—illustrates why they occur in high‑traffic systems, and provides practical techniques such as pre‑setting placeholder values, locking, and randomizing TTLs to keep databases healthy.
Under high‑concurrency loads, disk I/O becomes a bottleneck, prompting the use of caches; this article explains the fundamentals of caching, the role of memcached, and details its distributed implementation, covering simple modulo hashing, consistent hashing, and optimized virtual‑node techniques.
This article explains the fundamentals of caching, describes how memcached works as a distributed in‑memory cache, and details the hashing algorithms—including remainder hashing and consistent hashing with virtual nodes—used by clients to achieve scalable cache distribution.
This article examines various techniques for proactively refreshing Memcached entries before they expire, including dual‑key schemes, timestamp‑based checks, and lock‑based updates, and presents a preferred Java implementation that minimizes cache‑stampede and reduces memory overhead.
This article explores why Memcached expiration can cause sudden DB overload and presents five practical strategies—including periodic DB refresh, lock‑based queries, dual‑key schemes, and time‑embedded values—to proactively update caches and keep backend performance stable.
The article explains that 503 errors under high concurrency are usually caused by database bottlenecks and outlines a systematic approach—including read‑write separation, caching with memcached, consistent hashing, vertical partitioning, and horizontal sharding—to improve website scalability and reliability.
This article breaks down the core architecture, request protocols, and memory management mechanisms of Memcached and Redis, comparing their server models, highlighting their strengths and trade‑offs, and offering practical guidance for selecting and tuning these distributed caching solutions.
This article critically examines common claims that Memcached is superior for caching by comparing its design, threading, disk I/O, memory efficiency, LRU behavior, smart caching features, persistence, replication, observability, and Lua scripting capabilities against Redis, concluding that the two systems have distinct trade‑offs depending on use case.
Caching dramatically improves website performance by storing data in memory for faster responses and reducing database load, with Memcached and Redis as popular solutions; proper routing algorithms like consistent hashing are essential to scale clusters without causing cache misses or service disruption.
This article outlines nine practical PHP caching methods—including full-page static caching, partial page fragments, data and query caching, time‑based invalidation, Memcached, Apache modules, and opcode caches—to dramatically improve website speed and scalability.
This guide explains how to achieve high‑availability Tomcat session sharing in a clustered environment by installing and configuring MSM (Memcached Session Manager) with Memcached, setting up Nginx as a load balancer, and demonstrating failover handling for both Tomcat and Memcached nodes.
This article explains how to start Memcached with specific parameters, describes the resulting slab class configuration, illustrates memory allocation with pages, chunks, and slabs, and discusses item placement, waste, and the per‑slab LRU eviction policy in detail.
This article explains how to use Linux iptables to create network-level ACLs that block non-production IP ranges from accessing a Memcached server, providing command examples for adding, listing, and clearing firewall rules, and discusses future considerations such as IPv6 support.
This article examines common NoSQL key‑value stores such as Memcached and Redis, compares their strengths and limitations, and proposes a distributed architecture with routing, storage, management, and migration nodes that achieves high availability, automatic fault‑tolerance, load balancing, and elastic scaling.
The article breaks down Facebook's multi‑layered architecture, explaining how its PHP‑based web tier, Thrift‑driven services, Memcached caching, and specialized Erlang and C++ servers work together to deliver the News Feed and real‑time chat at massive scale.
The article provides a comprehensive overview of Flickr’s web architecture, detailing its massive traffic statistics, load‑balancing, PHP application servers, MySQL dual‑tree sharding, Memcached caching, search engine integration, and the evolution of its replication and scaling strategies.
