1
# 磁盘性能的数学分析
2
sequential_write = 150  # MB/s, 顺序写
3
random_write = 1.5      # MB/s, 随机写
4

5
# 顺序写比随机写快多少倍？
6
speedup = sequential_write / random_write
7
print(f"顺序写比随机写快 {speedup:.0f} 倍")
8
# 输出：顺序写比随机写快 100 倍

1
// 零拷贝的代码示例
2
// 传统方式
3
read(file_fd, buf, len);    // 内核 → 用户
4
write(socket_fd, buf, len); // 用户 → 内核
5

6
// 零拷贝方式
7
sendfile(socket_fd, file_fd, offset, len);
8
// 数据直接从文件缓冲区到网卡，不经过用户空间

1
# 批量发送 vs 单条发送
2
message_count = 10000
3
message_size = 1024  # 1KB
4

5
# 单条发送：每条消息一次网络请求
6
single_requests = message_count
7
single_overhead = single_requests * 0.1  # 假设每次请求 0.1ms 开销
8

9
# 批量发送：100 条消息一个批次
10
batch_size = 100
11
batch_count = message_count / batch_size
12
batch_overhead = batch_count * 0.1
13

14
print(f"单条发送开销：{single_overhead:.0f} ms")
15
print(f"批量发送开销：{batch_overhead:.0f} ms")
16
print(f"性能提升：{single_overhead/batch_overhead:.0f} 倍")
17

18
# 输出：
19
# 单条发送开销：1000 ms
20
# 批量发送开销：10 ms
21
# 性能提升：100 倍

1
// Kafka 生产者配置压缩
2
Properties props = new Properties();
3
props.put("compression.type", "lz4");  // 启用 LZ4 压缩
4
props.put("batch.size", 16384);        // 批次大小 16KB
5
props.put("linger.ms", 5);             // 等待 5ms 凑批次

1
# 分区数对吞吐量的影响
2
partitions = [1, 3, 6, 12, 24, 48]
3
base_tps = 50000  # 单分区 5 万 TPS
4

5
for p in partitions:
6
    tps = min(p * base_tps, 1000000)  # 上限 100 万
7
    print(f"{p} 分区: {tps/10000:.0f} 万 TPS")
8

9
# 输出：
10
# 1 分区: 5 万 TPS
11
# 3 分区: 15 万 TPS
12
# 6 分区: 30 万 TPS
13
# 12 分区: 60 万 TPS
14
# 24 分区: 100 万 TPS（达上限）
15
# 48 分区: 100 万 TPS（达上限）

1
# 页缓存命中率计算
2
total_reads = 1000000
3
cache_hits = 950000
4
cache_misses = total_reads - cache_hits
5

6
hit_rate = cache_hits / total_reads * 100
7
print(f"缓存命中率：{hit_rate:.1f}%")
8

9
# 95% 缓存命中意味着什么？
10
disk_latency = 0.1  # 0.1ms，SSD
11
memory_latency = 0.0001  # 0.1μs，内存
12

13
avg_latency = hit_rate/100 * memory_latency + (1-hit_rate/100) * disk_latency
14
print(f"平均读取延迟：{avg_latency*1000:.3f} ms")
15

16
# 输出：
17
# 缓存命中率：95.0%
18
# 平均读取延迟：0.005 ms

1
// 消费者配置优化
2
Properties props = new Properties();
3
props.put("fetch.min.bytes", 1024 * 1024);  // 最小拉取 1MB
4
props.put("fetch.max.wait.ms", 500);        // 最多等待 500ms
5
props.put("max.partition.fetch.bytes", 1024 * 1024);  // 单分区最大 1MB
6
props.put("max.poll.records", 500);         // 单次最多 500 条

1
# 生产者关键配置
2
producer:
3
  batch.size: 16384 # 批次大小 16KB
4
  linger.ms: 5 # 等待凑批次
5
  compression.type: lz4 # LZ4 压缩
6
  buffer.memory: 33554432 # 缓冲区 32MB
7
  acks: 1 # 平衡可靠性和性能
8

9
# Broker 关键配置
10
broker:
11
  num.network.threads: 3 # 网络线程数
12
  num.io.threads: 8 # IO 线程数
13
  log.flush.interval.messages: 10000 # 刷盘间隔
14
  num.partitions: 12 # 默认分区数
15

16
# 消费者关键配置
17
consumer:
18
  fetch.min.bytes: 1048576 # 最小拉取 1MB
19
  max.poll.records: 500 # 单次拉取上限
20
  max.partition.fetch.bytes: 1048576