This article walks through designing and implementing GoMemcache, a lightweight Go‑based distributed cache, covering use‑case selection, concurrency lock optimization, consistent hashing, production‑grade code, and practical deployment best practices for ultra‑low latency services.
This article walks through the fundamentals and advanced techniques for guaranteeing cache consistency, covering the Double‑Check pattern, root causes of inconsistency, interview‑ready questions, practical solutions like message queues, optimistic locking, multi‑level caching, and cutting‑edge schemes such as consistent hashing with singleflight.
The article examines the fundamental limitations of consistent hashing—its inability to preserve data locality, support range queries, and handle topology awareness—explaining why major storage systems such as Redis Cluster, TiDB, Ceph, and HBase have adopted alternative sharding strategies like hash slots, range partitioning, and CRUSH.
This article explores the fundamentals of message ordering in distributed message queues, explains why ordering is determined by broker arrival, compares global and partial ordering, and presents practical solutions—from single-partition designs to multi-partition hashing, handling data skew, and safe expansion—plus interview tips.
The article walks through why sharding is needed, outlines IO and CPU bottlenecks, presents two design principles, shows how to estimate capacity from existing data and growth trends, compares range, modulo, consistent‑hash and Snowflake sharding schemes, and details migration strategies for expanding nodes without downtime.
Redis Cluster distributes data using 16,384 hash slots calculated via CRC16, a design that offers flexible slot allocation, simpler data migration, and better performance compared to traditional consistent hashing, and this article explains the slot mechanism, node scaling, client routing, and the reasons behind the 16K slot choice.
Consistent hashing, a cornerstone of distributed systems, balances load, enhances scalability, and minimizes data migration; this article explains its fundamentals, the drawbacks of basic implementations, the role of virtual nodes, and provides a complete Go-language example with code for adding, removing, and locating nodes.
Consistent hashing replaces simple modulo‑based distribution to efficiently locate cached data across changing numbers of servers, using a hash ring and virtual nodes to ensure balanced load, minimize data movement, and improve reliability in distributed caching, load balancing, and database sharding scenarios.
This article explains the consistent hashing algorithm, its hash‑ring model, how it overcomes the limitations of simple modulo hashing in distributed caches, the role of virtual nodes for load balancing, and common use cases such as memcached, Redis clusters, and load‑balancing routers.
This article examines the challenges of growing B‑token data volumes, including table size limits and data skew, and proposes a solution using horizontal sharding with a consistent‑hash ring, dynamic table allocation, water‑level thresholds, periodic archiving, and monitoring to support future growth without costly migrations.
This article explains the fundamental concepts of Redis cluster architecture, covering high‑availability with Sentinel, data partitioning methods, proxy‑based sharding techniques, the mechanics of Redis Cluster without a central node, and practical considerations for multi‑key operations in a distributed environment.
This article explains core data sharding concepts and models—including hash‑based, range‑based, and consistent hashing—detailing their mappings, routing strategies, scalability considerations, and practical implementation examples for handling massive datasets in distributed systems.
This article explains fundamental distributed‑system mechanisms—including Bloom filters for space‑efficient membership tests, consistent hashing for scalable data placement, quorum requirements for operation safety, leader‑follower coordination, heartbeats, fencing, write‑ahead logging, log segmentation, high‑water marks, leases, gossip protocols, failure detection, split‑brain resolution, checksums, CAP and PACELC theorems, hinted handoff, read repair, and Merkle trees—providing a comprehensive overview for engineers.
This article introduces core distributed system concepts—including the CAP theorem, BASE model, consistent hashing, gossip protocol, Raft consensus algorithm, and common distributed transaction patterns like 2PC, 3PC, and TCC—explaining their definitions, trade‑offs, practical use cases, and implementation details.
This article introduces fundamental load balancing concepts and examines several static and dynamic algorithms—including round‑robin, weighted, smooth weighted round‑robin, consistent hashing, least‑active, and optimal‑response—providing Java code examples and discussing their advantages, disadvantages, and suitable use cases.
This article introduces essential distributed system design patterns such as Bloom filters, consistent hashing, quorum, leader‑follower architecture, heartbeat, fencing, write‑ahead logs, segmented logs, high‑water marks, leases, gossip protocol, Phi failure detection, split‑brain handling, checksums, CAP and PACELC theorems, hinted handoff, read repair, and Merkle trees, explaining their purpose and operation.
This article introduces essential distributed‑system concepts—including Bloom filters, consistent hashing, quorum, leader/follower roles, heartbeats, fencing, WAL, segment logs, high‑water marks, leases, gossip protocol, Phi failure detection, CAP and PACELC theorems, hinted handoff, read repair, and Merkle trees—explaining their purpose and how they are applied in systems such as BigTable, Cassandra, Dynamo, and Kafka.
This article explains the fundamentals of consistent hashing, its application in load‑balancing distributed caches, analyzes common issues such as data skew and cache avalanche, introduces virtual nodes for uniform distribution, provides Java code examples, and compares it with Redis's HashSlot approach.
This article explains common load‑balancing strategies—including round‑robin, random, weighted, smooth weighted round‑robin, consistent hashing, least‑active, and fastest‑response algorithms—provides Java implementations with code samples, discusses their advantages, disadvantages, and suitable scenarios, and offers practical guidance for choosing the right method in distributed systems.
This article reviews common load balancing strategies—including round-robin, random, weighted, smooth weighted round-robin, consistent hashing, least-active and optimal-response algorithms—explains their advantages and drawbacks, and provides complete Java code examples for each method.
This article explains essential distributed‑system concepts such as Bloom filters, consistent hashing, quorum, leader/follower roles, heartbeats, fencing, write‑ahead logs, segmented logs, high‑water marks, leases, gossip protocols, Phi accrual failure detection, split‑brain handling, checksums, the CAP and PACELC theorems, hinted handoff, read repair, and Merkle trees, illustrating each with practical examples and diagrams.
This article explains common load‑balancing strategies—including basic round‑robin, random, weighted and smooth weighted algorithms, as well as consistent hashing, least‑active and optimal‑response methods—provides Java implementations for each, discusses their advantages, disadvantages, and suitable scenarios, and concludes with practical recommendations.
This article explains Redis high‑availability strategies, covering basic hash sharding, the advantages of consistent hashing, client‑side versus proxy‑based partitioning, master‑slave replication, and the Sentinel failover mechanism, with diagrams illustrating node addition, removal, and failover decision processes.
This article explores practical solutions for implementing a distributed WebSocket cluster in a Spring Cloud environment, detailing the challenges of session sharing, comparing Netty and Spring WebSocket approaches, and presenting two strategies—session broadcasting and consistent‑hashing—along with gateway configuration, load‑balancing, and code examples.
This article explores practical approaches for building a distributed WebSocket cluster in a Spring Cloud environment, covering session handling, Netty versus Spring WebSocket implementations, session broadcasting, consistent‑hash routing, gateway configuration, Ribbon limitations, and provides code examples for each solution.
Consistent hashing maps both servers and keys onto a virtual hash ring, allowing keys to be assigned to the nearest clockwise server, which minimizes data movement during node addition or removal, improves load distribution with virtual nodes, and is widely used in distributed caching and load balancing systems.
The article explains consistent hashing—using a circular 2^32 hash ring with virtual nodes to evenly distribute keys across dynamic cache servers—provides a complete Go implementation including host registration, key lookup, and a bounded‑load extension that tracks server load, demonstrates a proxy‑cache setup, and discusses practical testing and production‑grade enhancements.
Database sharding improves performance by partitioning tables vertically or horizontally and routing rows with consistent hashing, while ShardingJDBC rewrites SQL for physical tables, adds missing columns, corrects pagination, splits batch inserts, and merges results using sorting, grouping, aggregation, and pagination engines.
This article explains the principles of consistent hashing, compares it with simple modulo hashing, and shows how the hash ring, virtual nodes, and key mapping improve load balancing, minimize data loss during node changes, and prevent cache avalanche in distributed caching systems.
Baidu’s Short Video Push System is a distributed platform serving hundreds of millions of users across multiple apps, delivering personalized, real‑time notifications via a modular architecture that includes material and user centers, recall, preprocessing, and delivery services, while optimizations such as activity‑based scheduling, bitmap‑based user segmentation, consistent‑hash frequency control, and protobuf compression boost click‑through rates, scalability, and resource efficiency.
This article walks through the challenges of multi‑user WebSocket communication in a clustered environment and presents two practical solutions—session broadcasting and a consistent‑hashing based routing—using Spring Boot, Spring Cloud Gateway, Redis, Netty, and Ribbon to achieve scalable, reliable real‑time messaging.
This article analyzes the challenges of multi‑user WebSocket communication in a clustered environment, compares Netty and Spring WebSocket implementations, and presents two practical solutions—session broadcast and a consistent‑hashing based routing scheme—complete with code samples, gateway configuration, and load‑balancing considerations.
This article explores practical approaches for enabling multi‑user communication in a distributed WebSocket cluster, covering session handling challenges, architecture design, technology stack choices, Netty versus Spring WebSocket implementations, consistent‑hashing load balancing, and detailed code examples for Spring Cloud Gateway and Ribbon integration.
This article explains the background, design criteria, and practical implementations of horizontal database sharding—including range, hash, gene, routing‑table, and consistent‑hash methods—while discussing common pitfalls, data‑skew mitigation, and both doubling and consistent‑hash expansion techniques for MySQL clusters.
This article details how a rapidly growing e‑commerce platform migrated from a single MySQL instance to a 16‑shard architecture using Sharding‑Jdbc, introduced consistent‑hashing to mitigate data skew, leveraged ES+HBase for multi‑dimensional queries, and implemented zero‑downtime migration strategies such as dual‑write and Canal replication.
Effective MySQL sharding requires sustainable, low‑skew designs, favoring hash‑based methods with proper coprime counts, two‑stage partitioning, routing tables, or consistent hashing, while supporting expansion via doubling or flexible consistent‑hash growth to avoid hot spots and uneven data distribution.
The article compares four consistent‑hashing algorithms—Ketama’s ring with virtual nodes, Rendezvous’s highest‑random‑weight method, Google’s Jump Consistent Hash, and Maglev’s lookup‑table approach—evaluating their balance, monotonicity, stability, scalability, and time complexity, and concludes that Ketama and Jump offer the best overall trade‑off.
This article reviews the seven‑year evolution of Ctrip's microservice service‑registry from manual data maintenance through an etcd‑based solution to the self‑developed Artemis system, detailing its architecture, consistent‑hash data partitioning, high‑availability design, and second‑level instance up/down mechanisms.
This article explains the drawbacks of a basic modulo hash algorithm for key distribution, demonstrates how consistent hashing resolves scaling and node‑failure issues, and discusses virtual‑node techniques to mitigate data skew and improve load balancing in distributed cache systems.
This article explains how consistent hashing, combined with Docker-based microservice architectures, reduces data movement during dynamic scaling by using a ring‑shaped hash space and intelligent node placement, making auto‑scaling more efficient and resilient.
This article explains the fundamentals of consistent hashing, compares the classic ring‑based method with the more efficient jump consistent hash algorithm, provides reference implementations in C++, discusses their time‑complexity and practical trade‑offs, and shows how they are applied in systems such as Greenplum.
The article uses a historical story to illustrate basic hash‑based partitioning, its shortcomings when nodes change, and then introduces consistent hashing, hash rings, and virtual nodes as solutions for balanced load distribution and minimal data migration in distributed systems.
This article explains Redis sharding, covering its purpose, various partitioning methods such as range and hash partitioning, implementation approaches like client‑side and proxy‑assisted sharding, their drawbacks, and practical steps for migration and using Redis Cluster or Twemproxy.
This article experimentally validates consistent hashing by adding and removing nodes in a 5‑node cluster, reveals key distribution imbalance and avalanche risks, and proposes solutions such as node scaling and virtual node virtualization, complete with Python code examples and detailed analysis.
This article experimentally validates consistent hashing by adding and removing nodes in a simulated cluster, examines key redistribution, reveals load‑imbalance and avalanche vulnerabilities, and proposes solutions such as virtual nodes and adaptive replica factors, providing Python code examples and detailed observations.
This article explains the principle of consistent hashing, shows how to build a 2^32‑range hash ring, map nodes and keys onto it, and demonstrates node addition and removal with a Python implementation that highlights reduced data reshuffling compared to simple modulo hashing.
This article explains the principles of consistent hashing, compares it with simple modulo and virtual bucket methods, demonstrates how to build a hash ring, map nodes and keys, and shows through Python code how node addition or removal only affects a small portion of the data.
This article explains Redis Cluster’s automatic sharding, built‑in high availability, the role of the cluster bus ports, the limitations of traditional hash algorithms, and how consistent hashing with virtual nodes and the 16384‑slot hash slot mechanism enable efficient data distribution and low‑cost node scaling.
This article explains the fundamentals of hash functions, outlines the key characteristics of a good hash algorithm, and dives deep into consistent hashing—its background, mechanism, desirable properties, fault tolerance, scalability, and the use of virtual nodes to solve data skew in distributed systems.
Consistent hashing, introduced by MIT in 1997, addresses hotspot issues in distributed systems by ensuring balance, monotonicity, spread, and load properties, using a ring hash space, virtual nodes, and minimal data movement when nodes are added or removed.
This article explains the concept of consistent hashing, its application in distributed cache load balancing, analyzes issues like data skew and cache avalanche, presents virtual‑node optimizations with Java test code, discusses graceful scaling strategies, and compares it to Redis’s HashSlot and P2P approaches.
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 details Xiaomi's journey from Kafka 0.8 to the home‑grown Talos system, covering business motivations, storage‑compute separation architecture, key challenges such as tail‑read and consistency, and extensive performance, resource, and platform optimizations that enable a high‑throughput, multi‑tenant messaging service.
This article uses a classic distributed caching scenario to explain consistent hashing, detailing its principles, advantages, challenges like cache avalanche, and solutions such as virtual nodes, while illustrating each step with clear diagrams and examples.
This article explains the principles of consistent hashing, demonstrates how to implement a custom ordered map and a TreeMap‑based solution for node selection, compares their performance, and shows how to integrate the algorithm into a routing framework with extensible strategies for backend services.
The article explains how distributed storage systems solve the fundamental problems of data sharding and redundancy by describing three sharding methods (hash, consistent‑hash, and range‑based), the criteria for choosing a shard key, the role of metadata servers, and consistency techniques such as leasing, all illustrated with concrete examples and code snippets.
This article explains the core concepts of data sharding in distributed storage systems, compares hash, consistent‑hash, and range‑based partitioning, discusses how to choose sharding keys, examines metadata server designs and high‑availability solutions, and introduces lease‑based cache consistency mechanisms.
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.
The article describes how the Nitro team designed and implemented a Go‑based consistent‑hashing router that leverages Nginx, the Redis protocol, Envoy sidecars, and Mesos to provide low‑latency, high‑throughput request routing and caching for compute‑intensive services.
This article explains Dynamo, the decentralized key‑value storage system, covering its design goals, consistent‑hashing partitioning with virtual nodes, replication strategies, quorum‑based consistency, conflict resolution with vector clocks, hinted handoff, Merkle‑tree synchronization, and gossip‑based failure detection.
This article explains the limitations of simple modulo hashing for Redis clusters, introduces consistent hashing with a virtual‑node ring to achieve fault tolerance and seamless scaling, and demonstrates how the algorithm reduces data skew and improves cache performance in distributed systems.
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 explains why and when to move to distributed architecture, outlines the typical upgrade and splitting steps, and details five common distributed cluster patterns—including load balancing, leader election, blockchain, master‑slave, and consistent hashing—highlighting their trade‑offs and use cases.
TDSQL’s cloud‑based audit solution combines a three‑proxy high‑availability layer, Kafka’s O(1) persistent messaging, and a distributed audit‑server that uses consistent hashing and multi‑coroutine processing to consume data within seconds, while fault‑tolerant offsets, majority acknowledgments, and Tencent Cloud MongoDB storage ensure secure, ordered, scalable, and highly reliable audit logging.
Google’s internal Maglev load balancer, described in a recent research paper, bypasses the kernel to operate directly on the NIC, uses ECMP routing, consistent hashing, and memory‑shared queues to achieve sub‑microsecond packet processing while scaling horizontally across clusters.
This article explores the core difficulties of distributed systems—including network latency, failures, the CAP theorem, consistency models, and common techniques such as consistent hashing, quorum, vector clocks, lease mechanisms, gossip protocols, and distributed transaction protocols—providing practical insights and references for building robust scalable architectures.
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 explains how to achieve website scalability through physical separation, server clustering, various load‑balancing techniques, consistent‑hashing for distributed caches, and scaling strategies for relational and NoSQL databases, providing practical guidance for building resilient back‑end 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.
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.
Consistent hashing organizes the hash space into a virtual ring, allowing cache servers and objects to be mapped with minimal disruption when servers are added or removed, thereby reducing cache misses and backend load compared to traditional modulo‑based hashing.
This article explains the concept, benefits, methods, and practical considerations of partitioning data across multiple Redis instances, covering range and hash partitioning, consistent hashing, implementation options, drawbacks, and recommended tools such as Redis Cluster and Twemproxy.
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 explains the consistent hashing algorithm, its motivation in cache systems, the concept of monotonicity, the step‑by‑step mapping process, and how virtual nodes improve balance and resilience when cache servers are added or removed.
This article explains the principles of consistent hashing, its classic design with virtual nodes, the shortcomings of the original algorithm, and how Amazon's Dynamo and other extensions improve load balancing and reduce data movement in distributed environments.
