Load Balancing: Round Robin vs Least Connections

class RoundRobinBalancer:
    def __init__(self, servers):
        self.servers = servers
        self.next_index = 0

    def pick(self):
        server = self.servers[self.next_index]
        self.next_index = (self.next_index + 1) % len(self.servers)
        return server

servers = ["server-a", "server-b", "server-c"]
rr = RoundRobinBalancer(servers)
counts = {s: 0 for s in servers}
for i in range(10):
    counts[rr.pick()] += 1
print(f"10 requests across 3 servers: {counts}")

$ python uneven_split.py
10 requests across 3 servers: {'server-a': 4, 'server-b': 3, 'server-c': 3}

10 doesn’t divide evenly by 3, so whichever server happens to be next when the count runs out gets one extra request — “equal” only means equal over a window that’s a multiple of the server count.

class LeastConnectionsBalancer:
    def __init__(self, servers):
        self.active = {s: 0 for s in servers}

    def pick(self):
        return min(self.active, key=self.active.get)

    def start(self, server):
        self.active[server] += 1

    def finish(self, server):
        self.active[server] -= 1

servers = ["server-a", "server-b", "server-c"]
lc = LeastConnectionsBalancer(servers)

# server-a starts with 3 in-flight requests
for _ in range(3):
    lc.start("server-a")

s1 = lc.pick()
lc.start(s1)
print(f"request 1 -> {s1} (active: {lc.active})")

# server-a's requests finish
for _ in range(3):
    lc.finish("server-a")

s2 = lc.pick()
lc.start(s2)
print(f"request 2 -> {s2} (active: {lc.active})")

$ python rebalance_after_finish.py
request 1 -> server-b (active: {'server-a': 3, 'server-b': 1, 'server-c': 0})
request 2 -> server-a (active: {'server-a': 1, 'server-b': 1, 'server-c': 0})

The moment server-a’s 3 requests finish, it drops back to 0 active connections and becomes eligible again — least connections has no memory of a server having been slow earlier, only what its load looks like right now.

class WeightedRoundRobinBalancer:
    def __init__(self, weighted_servers):
        # weighted_servers: list of (server, weight)
        self.schedule = []
        for server, weight in weighted_servers:
            self.schedule.extend([server] * weight)
        self.next_index = 0

    def pick(self):
        server = self.schedule[self.next_index]
        self.next_index = (self.next_index + 1) % len(self.schedule)
        return server

# server-a is a bigger machine, gets 3x the share
wrr = WeightedRoundRobinBalancer([("server-a", 3), ("server-b", 1), ("server-c", 1)])
counts = {}
for _ in range(10):
    s = wrr.pick()
    counts[s] = counts.get(s, 0) + 1
print(f"10 requests, server-a weighted 3x: {counts}")

$ python weighted_round_robin.py
10 requests, server-a weighted 3x: {'server-a': 6, 'server-b': 2, 'server-c': 2}

Building the rotation schedule once (["server-a", "server-a", "server-a", "server-b", "server-c"]) turns weighting into the same plain round robin as before — the weight lives in how many times a server appears in the list, not in any new logic in pick.

class HealthAwareRoundRobin:
    def __init__(self, servers):
        self.servers = servers
        self.healthy = set(servers)
        self.next_index = 0

    def mark_unhealthy(self, server):
        self.healthy.discard(server)

    def pick(self):
        for _ in range(len(self.servers)):
            server = self.servers[self.next_index]
            self.next_index = (self.next_index + 1) % len(self.servers)
            if server in self.healthy:
                return server
        raise RuntimeError("no healthy servers")

servers = ["server-a", "server-b", "server-c"]
balancer = HealthAwareRoundRobin(servers)
balancer.mark_unhealthy("server-b")

counts = {}
for i in range(6):
    s = balancer.pick()
    counts[s] = counts.get(s, 0) + 1
    print(f"request {i + 1} -> {s}")
print(f"distribution: {counts}")

$ python health_aware.py
request 1 -> server-a
request 2 -> server-c
request 3 -> server-a
request 4 -> server-c
request 5 -> server-a
request 6 -> server-c
distribution: {'server-a': 3, 'server-c': 3}

server-b never appears in the output at all — the for _ in range(len(self.servers)) loop lets pick skip past an unhealthy server without an infinite loop, as long as at least one server is still marked healthy.