亿级商品存储下，如何深度回答分布式系统的原理性问题（对话式 + 脑图 + Go）

package main

import (
	"fmt"
	"hash/crc32"
)

// HashRouter 最简单的取模哈希分片路由
type HashRouter struct {
	nodes []string
}

func NewHashRouter(nodes ...string) *HashRouter {
	return &HashRouter{nodes: nodes}
}

// Route 根据分片键返回目标节点
func (r *HashRouter) Route(key string) string {
	if len(r.nodes) == 0 {
		return ""
	}
	h := crc32.ChecksumIEEE([]byte(key))
	return r.nodes[h%uint32(len(r.nodes))]
}

func main() {
	r := NewHashRouter("NodeA", "NodeB", "NodeC", "NodeD")
	for _, id := range []string{"product-100", "product-101", "product-2024"} {
		fmt.Printf("%s -> %s\n", id, r.Route(id))
	}
}

package main

import "fmt"

// RangeRouter 按商品ID的数值区间分片
type RangeRouter struct {
	// 每个分片的区间上界（不含）与节点名
	bounds []struct {
		end  uint64
		node string
	}
}

func NewRangeRouter() *RangeRouter {
	r := &RangeRouter{}
	// 每 100 万一个分片
	r.bounds = []struct {
		end  uint64
		node string
	}{
		{1_000_000, "NodeA"},
		{2_000_000, "NodeB"},
		{3_000_000, "NodeC"},
		{^uint64(0), "NodeD"}, // 兜底
	}
	return r
}

func (r *RangeRouter) Route(id uint64) string {
	for _, b := range r.bounds {
		if id < b.end {
			return b.node
		}
	}
	return "NodeD"
}

func main() {
	r := NewRangeRouter()
	for _, id := range []uint64{50, 1_500_000, 2_500_000} {
		fmt.Printf("商品 %d -> %s\n", id, r.Route(id))
	}
}

package main

import (
	"fmt"
	"hash/crc32"
	"sort"
)

// ConsistentHash 带虚拟节点的一致性哈希环
type ConsistentHash struct {
	ring         map[uint32]string // 哈希值 -> 真实节点
	sortedKeys   []uint32          // 已排序的哈希值，用于顺时针查找
	virtualNodes int
}

func NewConsistentHash(virtualNodes int) *ConsistentHash {
	return &ConsistentHash{
		ring:         make(map[uint32]string),
		sortedKeys:   nil,
		virtualNodes: virtualNodes,
	}
}

func (c *ConsistentHash) hash(key string) uint32 {
	return crc32.ChecksumIEEE([]byte(key))
}

// Add 加入一个真实节点，并为它生成 virtualNodes 个虚拟节点
func (c *ConsistentHash) Add(node string) {
	for i := 0; i < c.virtualNodes; i++ {
		vkey := fmt.Sprintf("%s#%d", node, i)
		h := c.hash(vkey)
		c.ring[h] = node
		c.sortedKeys = append(c.sortedKeys, h)
	}
	sort.Slice(c.sortedKeys, func(i, j int) bool {
		return c.sortedKeys[i] < c.sortedKeys[j]
	})
}

// Get 顺时针找到 key 落到的第一个节点
func (c *ConsistentHash) Get(key string) string {
	if len(c.sortedKeys) == 0 {
		return ""
	}
	h := c.hash(key)
	idx := sort.Search(len(c.sortedKeys), func(i int) bool {
		return c.sortedKeys[i] >= h
	})
	if idx == len(c.sortedKeys) {
		idx = 0 // 越过环尾，绕回环首
	}
	return c.ring[c.sortedKeys[idx]]
}

func main() {
	ch := NewConsistentHash(10)
	for _, n := range []string{"NodeA", "NodeB", "NodeC", "NodeD"} {
		ch.Add(n)
	}

	// 预置 1000 个商品
	keys := make([]string, 1000)
	for i := range keys {
		keys[i] = fmt.Sprintf("product-%d", i)
	}
	before := make(map[string]string, len(keys))
	for _, k := range keys {
		before[k] = ch.Get(k)
	}

	// 扩容：加入第 5 台 NodeE
	ch.Add("NodeE")

	moved := 0
	for _, k := range keys {
		if ch.Get(k) != before[k] {
			moved++
		}
	}
	fmt.Printf("取模分片 4→5：约 80%% 的 key 需迁移\n")
	fmt.Printf("一致性哈希 4→5：仅 %d/%d 个 key 迁移，约 %.1f%%\n",
		moved, len(keys), float64(moved)/float64(len(keys))*100)
}

package main

import "fmt"

type Role int

const (
	Primary Role = iota
	Replica
	Offline
)

type Node struct {
	name string
	role Role
}

// failover 主节点下线，从节点中第一个接管为主
func failover(nodes []*Node) {
	for _, n := range nodes {
		if n.role == Primary {
			fmt.Printf("[检测] 主节点 %s 心跳丢失，标记下线\n", n.name)
			n.role = Offline
		}
	}
	for _, n := range nodes {
		if n.role == Replica {
			n.role = Primary
			fmt.Printf("[切换] %s 接管为新的主节点，继续对外服务\n", n.name)
			return
		}
	}
	fmt.Println("[告警] 没有可用从节点，服务不可用")
}

func main() {
	nodes := []*Node{
		{name: "NodeA", role: Primary},
		{name: "NodeB", role: Replica},
		{name: "NodeC", role: Replica},
	}
	failover(nodes)
}

package main

import "fmt"

// Participant 简化参与者
type Participant struct {
	name  string
	ready bool // 是否准备好提交
}

// Coordinator 两阶段提交协调者
type Coordinator struct {
	parts []*Participant
}

func (c *Coordinator) commit() bool {
	// 阶段一：准备
	fmt.Println("[阶段一] 协调者发送 Prepare")
	for _, p := range c.parts {
		if !p.ready {
			fmt.Printf("  %s 回答 No\n", p.name)
			c.rollback()
			return false
		}
		fmt.Printf("  %s 回答 Yes\n", p.name)
	}
	// 阶段二：提交
	fmt.Println("[阶段二] 全员 Yes，发送 Commit")
	return true
}

func (c *Coordinator) rollback() {
	fmt.Println("[阶段二] 存在 No，全员 Rollback")
}

func main() {
	c := &Coordinator{parts: []*Participant{
		{name: "分片A", ready: true},
		{name: "分片B", ready: true},
	}}
	fmt.Println("提交结果:", c.commit())
}

package main

import "fmt"

type Role int

const (
	Follower Role = iota
	Candidate
	Leader
)

type Node struct {
	id    string
	term  int
	role  Role
	votes int
}

// startElection 发起一轮选举，返回是否当选 Leader
func (n *Node) startElection(peerCount int) bool {
	n.term++            // ① 任期 +1
	n.role = Candidate  // ② 变成候选者
	n.votes = 1         // ③ 给自己投一票
	// 简化：假设向其余 peer 拉票，全部同意
	n.votes += peerCount
	// ④ 必须拿到多数派（含自己）
	needed := peerCount/2 + 1
	if n.votes >= needed {
		n.role = Leader
		return true
	}
	return false
}

func main() {
	n := &Node{id: "NodeA", term: 0, role: Follower}
	if n.startElection(4) { // 集群共 5 节点（自己+4 peer）
		fmt.Printf("%s 在 term=%d 当选 Leader\n", n.id, n.term)
	}
}