Consistent hashing maps both keys and servers onto a circular hash space (a ring). Each key is owned by the first server found clockwise from the key's position, so adding or removing a server only affects keys near that server.

With hash(key) mod N, changing N reshuffles almost every key, because the modulus changes for all of them. Consistent hashing avoids this by decoupling key positions from the number of servers.

On average only about 1/N of the keys move, where N is the number of servers, because a new server claims just the arc of the ring between it and the previous server clockwise.

Each physical server is placed at many points on the ring, called virtual nodes or replicas. Instead of one position per server, V positions spread ownership into many small arcs, evening out load.

With one point per server, random placement can give some servers huge arcs and others tiny ones. Many virtual nodes average out these variations, so each physical server gets a fairer share of keys.

The key is hashed to a position on the ring, then you walk clockwise until you hit the first server (virtual node). That server owns the key. If you pass the top of the ring, you wrap around to the start.

It powers distributed caches like memcached client sharding, key-value stores such as Amazon Dynamo, Cassandra and Riak, content delivery networks, and peer-to-peer distributed hash tables (DHTs) like Chord.

Only the keys owned by the removed server's virtual nodes are reassigned. Each affected key moves clockwise to the next surviving server, while all other keys stay exactly where they were.

In practice systems use anywhere from around 100 to several hundred virtual nodes per server. More replicas give smoother balance but cost more memory and lookup-structure overhead.

A hash function maps each key and each virtual node label to a number in a fixed range, for example 0 to 2^32 − 1. That range is treated as a circle, so the largest value wraps around to the smallest.