数据结构 on Liangweidong's blog

Java 面试合集：Redis 数据结构与线程模型

Fri, 15 Jun 2018 00:00:00 +0800

本文写于 2018 年 6 月——Redis 4.0 主线、Redis 5.0（Stream 类型）2018-10 发布前夜。

一、8 大数据类型应用场景

类型	场景	底层实现	说明
String	缓存 / 计数器 / 限流 / 分布式锁 / 共享 Session	int + SDS（简单动态字符串）	最基础类型
Hash	缓存对象 / 购物车	压缩列表 / 哈希表	7.0 中，压缩列表已经废弃了，交由 listpack 来实现了
List	消息队列	双向链表 / 压缩列表	简单的字符串列表，最大长度为 `2^32 - 1`，40 亿。3.2 版本之后，底层数据结构就只由 quicklist 实现了
Set	点赞 / 共同关注 / 抽奖活动	哈希表 / 整数集合	无序并唯一的键值集合
ZSet	排行榜 / 电话排序 / 姓名排序	压缩列表 / 跳表	7.0 中，压缩列表已经废弃了，交由 listpack 来实现了
BitMap（2.2 版新增）	签到 / 用户登陆状态 / 布隆过滤器	String	统计二值状态
HyperLogLog（2.8 版新增）	百万级以上的网页 UV 计数	自定义	用于「统计基数」
GEO（3.2 版新增）	滴滴叫车	Sorted Set	地理坐标
Stream（5.0 版新增）	消息队列	自定义	完美地实现消息队列

1.1 选型决策

graph TD
 A[需要存什么?] --> B{单个值?}
 B -->|是| C[String / BitMap / HyperLogLog]
 B -->|否| D{有序?}
 D -->|是| E[ZSet / List / Stream]
 D -->|否| F{唯一?}
 F -->|是| G[Set]
 F -->|否| H[Hash / List]

二、Redis 线程模型

2.1 单线程 vs 多线程

Redis 单线程指的是「接收客户端请求 → 解析请求 → 进行数据读写等操作 → 发送数据给客户端」这个过程是由一个线程（主线程）来完成的，这也是我们常说 Redis 是单线程的原因。

但是，Redis 程序并不是单线程的，Redis 在启动的时候是会启动后台线程（BIO）的：

Redis 在 2.6 版本，会启动 2 个后台线程，分别处理关闭文件、AOF 刷盘这两个任务
Redis 在 4.0 版本之后，新增了一个新的后台线程，用来异步释放 Redis 内存，也就是 lazyfree 线程

2.2 Redis 6.0 引入多线程 I/O

虽然 Redis 的主要工作（网络 I/O 和执行命令）一直是单线程模型，但是 在 Redis 6.0 版本之后，也采用了多个 I/O 线程来处理网络请求，这是因为随着网络硬件的性能提升，Redis 的性能瓶颈有时会出现在网络 I/O 的处理上。

所以为了提高网络 I/O 的并行度，Redis 6.0 对于网络 I/O 采用多线程来处理。但是对于命令的执行，Redis 仍然使用单线程来处理。 所以大家不要误解 Redis 有多线程同时执行命令。

Redis 官方表示，Redis 6.0 版本引入的多线程 I/O 特性对性能提升至少是一倍以上。

2.3 6.0 线程数配置

1
2
3
4
5


// 读请求也使用 io 多线程
io-threads-do-reads yes

// io-threads N，表示启用 N-1 个 I/O 线程（主线程也算一个 I/O 线程）
io-threads 4

官方的建议是如果为 4 核的 CPU，建议线程数设置为 2 或 3，如果为 8 核 CPU 建议线程数设置为 6，线程数一定要小于机器核数，线程数并不是越大越好。

2.4 Redis 启动后的线程组成

因此， Redis 6.0 版本之后，Redis 在启动的时候，默认情况下会 额外创建 6 个线程 （这里的线程数不包括主线程 ）：

Redis-server：Redis 的主线程，主要负责执行命令

bio_close_file、bio_aof_fsync、bio_lazy_free：三个后台线程，分别异步处理关闭文件任务、AOF 刷盘任务、释放内存任务

io_thd_1、io_thd_2、io_thd_3：三个 I/O 线程，io-threads 默认是 4，所以会启动 3（4-1）个 I/O 多线程，用来分担 Redis 网络 I/O 的压力

三、Redis 为什么这么快

3.1 4 大核心原因

Redis 快的核心原因，可以用一句话概括：它干的活极其简单，而且它把单线程的优势发挥到了极致，同时通过操作系统底层的"高级外挂"解决了高并发的排队问题。

原因 1：绝大多数请求是纯内存操作

这是最根本的基础。Redis 的所有数据都存储在内存中，CPU 读写内存的速度（纳秒级别）比起读写机械硬盘或 SSD（微秒甚至毫秒级别）快了数万倍。

原因 2：避免了多线程的"内耗"

多线程虽然能并发，但也带来了高昂的代价。Redis 采用单线程，反而完美避开了这些性能杀手：

没有线程切换的开销：操作系统在切换线程时，需要保存当前线程的上下文并加载新线程的数据。单线程一个人干到底，零切换成本
没有锁的竞争：多线程访问共享资源必须加锁，加锁、解锁以及等待锁的操作非常重。Redis 单线程天然保证了所有操作都是原子性的，根本不需要锁

原因 3：I/O 多路复用技术（底层外挂）

“单线程"指的是 Redis 核心的网络事件处理器和键值对读写命令 是由一个线程串行执行的。但面对海量的客户端连接，单线程怎么可能忙得过来？

这就是 I/O 多路复用（I/O Multiplexing） 大显身手的地方。Redis 利用了操作系统底层的非阻塞 I/O 机制（在 Linux 上通常是 epoll）。

epoll 工作原理：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


┌─────────────────────────────────────────┐
│ Redis 主线程 │
│ ┌──────────────────┐ │
│ │ epoll_wait() │ ← 阻塞等事件 │
│ └──────────────────┘ │
│ ↓ 有事件发生 │
│ 遍历 fd_list，处理每个就绪 fd │
│ ├─ Client 1: read() │
│ ├─ Client 5: read() │
│ └─ Client 100: read() │
│ ↓ 业务逻辑 │
│ 执行 Redis 命令（单线程原子） │
│ ↓ 写回响应 │
│ write() → 多线程异步 │
└─────────────────────────────────────────┘

epoll 优势：

select：O(n) 遍历所有 fd
poll：O(n) 遍历所有 fd
epoll：O(1) 事件通知（内核维护就绪链表）

原因 4：精心优化的数据结构

数据结构	优化
SDS	O(1) 长度获取、避免缓冲区溢出、二进制安全
跳跃表	O(log N) 范围查询，替代红黑树
压缩列表	连续内存 + 紧凑编码
dict（哈希表）	渐进式 rehash，不阻塞

四、内存淘汰策略

4.1 8 大策略

策略	描述
noeviction（默认）	不淘汰，写入失败返回错误
allkeys-lru	所有 key 中淘汰最近最少使用
allkeys-lfu（4.0+）	所有 key 中淘汰最不经常使用
allkeys-random	所有 key 中随机淘汰
volatile-lru	设置过期的 key 中淘汰 LRU
volatile-lfu（4.0+）	设置过期的 key 中淘汰 LFU
volatile-random	设置过期的 key 中随机淘汰
volatile-ttl	设置过期的 key 中淘汰最近过期

4.2 选型建议

缓存场景（容忍丢失）：allkeys-lru / allkeys-lfu
数据不能丢：noeviction + 监控告警
混合场景：volatile-lru（仅淘汰过期 key）

五、持久化机制

5.1 三大方式

方式	文件	频率	性能	数据安全
RDB	dump.rdb	定时 / 手动	高	较低（可能丢失最后一次快照后的数据）
AOF	appendonly.aof	每秒	中	较高（仅丢失 1s 数据）
混合（4.0+）	dump + aof	-	中高	高

5.2 RDB 触发

1
2
3
4
5
6
7
8


# 自动触发（save 命令）
save 900 1 # 900 秒内至少 1 个 key 变更
save 300 10 # 300 秒内至少 10 个 key 变更
save 60 10000 # 60 秒内至少 10000 个 key 变更

# 手动触发
bgsave # 后台异步保存
save # 同步保存（阻塞主线程）

5.3 AOF 三种策略

1
2
3
4


# appendfsync 策略
appendfsync always # 每次写入同步刷盘（最安全，最慢）
appendfsync everysec # 每秒刷盘（默认，推荐）
appendfsync no # 操作系统决定（最快，最不安全）

六、Redis 集群方案

方案	数据分片	高可用	适用
主从复制	✗	手动故障切换	简单备份
Sentinel	✗	自动故障切换	中小规模
Codis	✓	手动 + 代理	国产分片方案
Cluster	✓（16384 slot）	自动故障切换	大规模生产

七、Redis 经典问题

7.1 缓存雪崩

现象：大量 key 同时过期，请求打到数据库。

解决方案：

过期时间加随机值：expire = base + random(0, 300)
熔断降级：数据库压力过大时直接拒绝部分请求
缓存预热：系统启动时把热点数据加载到缓存

7.2 缓存穿透

现象：查询不存在的 key，每次都打到数据库。

解决方案：

空值缓存：key -> null（短 TTL）
布隆过滤器：先过布隆过滤器
接口校验：参数合法性检查

7.3 缓存击穿

现象：热点 key 突然过期，瞬间大量请求打到数据库。

解决方案：

分布式锁：第一个请求查 DB，后续请求等
永不过期：逻辑过期（不设 TTL，值带过期时间字段）
熔断降级：直接返回旧值

7.4 数据不一致

现象：数据库和缓存数据不一致。

解决方案：

先更新 DB，再删除缓存（Cache-Aside Pattern）
延迟双删：更新 DB → 删除缓存 → 异步延迟再删
binlog 订阅：监听 binlog 异步更新缓存
设置较短 TTL：最终一致性兜底

八、写在最后

Redis 面试要点：

基础：8 大数据类型 + 选型

线程模型：单线程 vs 多线程 I/O、I/O 多路复用

快的原因：内存操作 + 无锁 + epoll + 优化数据结构

持久化：RDB / AOF / 混合

集群：主从 / Sentinel / Cluster

经典问题：雪崩 / 穿透 / 击穿 / 一致性

参考资料

常见排序算法完全指南：从冒泡到堆排序

Fri, 17 Aug 2012 00:00:00 +0000

排序算法是算法学习的"第一道关卡"，也是面试最高频的考点之一。常见排序家族大致可以分为 O(n²) 简单排序、O(n log n) 高效排序、O(n) 特殊排序 三大类。这篇文章会带你用一张复杂度总览图 + 7 个核心排序的代码与动图串起整个知识体系。

为什么学排序？ 排序看似简单，但它几乎是所有算法面试的"开胃菜"——它同时考察你时间/空间复杂度分析、稳定性判断、原地/非原地、递归/迭代等基础能力。更重要的是，很多高级算法（如二分查找、归并思想、Timsort）都建立在排序之上。

一、复杂度总览

一张图看懂 10 种常见排序的复杂度、稳定性、空间开销：

图源说明：上方图片来自原 常见排序.md 文档的复杂度对比图，汇总了各种排序算法在最好/最坏/平均时间复杂度、空间复杂度、稳定性等关键维度上的表现，建议先记住这张图，再去深入单个算法。

速记口诀

类别	包含算法	时间复杂度	稳定性	一句话记忆
简单排序	冒泡 / 选择 / 插入	O(n²)	冒泡✓ 选择✗ 插入✓	“三巨头”——最好写、最慢
高效排序	希尔 / 归并 / 快速 / 堆	O(n log n)	归并✓ 其他✗	“工业级”——面试重点
特殊排序	计数 / 桶 / 基数	O(n + k)	✓	“非比较”——特定场景起飞
高级混合	Timsort / Introsort	O(n log n)	✓	真实语言内置的排序

二、冒泡排序：入门第一课

动图演示：

图源说明：上方 GIF 来自原 常见排序.md 文档，演示了冒泡排序逐轮把最大元素"冒泡"到末尾的过程。

2.1 核心思想

像水里的气泡一样，两两比较相邻元素，如果前面的比后面的大就交换；这样一轮下来最大的元素一定会"浮"到最右边；重复这个过程 n-1 轮即可完成排序。

2.2 Python 实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


from typing import List, Optional

def bubble_sort(arr: List[int]) -> List[int]:
 """冒泡排序：原地、稳定、O(n²)"""
 n = len(arr)
 for i in range(n - 1):
 swapped = False
 for j in range(n - 1 - i):
 if arr[j] > arr[j + 1]:
 arr[j], arr[j + 1] = arr[j + 1], arr[j]
 swapped = True
 # 优化：如果这一轮没有交换，说明已经有序
 if not swapped:
 break
 return arr

2.3 关键点

稳定性：✓ 稳定（相等元素不会交换相对顺序）
原地性：✓ 原地排序（空间 O(1)）
最好情况：O(n)（输入已经有序，加 swapped 标志可提前结束）
最坏情况：O(n²)（逆序输入）
为什么面试爱考：能引出"标志位优化"、"鸡尾酒排序（双向冒泡）“等延伸讨论

2.4 常见坑

❌ 内层循环写成 range(n) 而不是 range(n - 1 - i)——每一轮多比较已经排好序的尾巴
❌ 漏掉 swapped 标志位——失去了"已经有序就提前结束"的优化
❌ 把”=“和”>“搞反——影响稳定性判断

三、选择排序：最直白但最慢

3.1 核心思想

每一轮从未排序部分找出最小值，放到已排序部分的末尾。

3.2 Python 实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


from typing import List, Optional

def selection_sort(arr: List[int]) -> List[int]:
 n = len(arr)
 for i in range(n - 1):
 min_idx = i
 for j in range(i + 1, n):
 if arr[j] < arr[min_idx]:
 min_idx = j
 if min_idx != i:
 arr[i], arr[min_idx] = arr[min_idx], arr[i]
 return arr

3.3 关键点

稳定性：✗ 不稳定（交换会跨过相等元素）
原地性：✓ 原地
复杂度：无论输入如何都是 O(n²)（没有最好情况优化）
优势：交换次数最少（最多 n-1 次），适合"交换代价高"的场景（如写 SSD）

四、插入排序：数据越有序越快

4.1 核心思想

把数组分为"已排序区"和"未排序区”，每次从未排序区取一个元素，向前找到它在已排序区里的插入位置。

4.2 Python 实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


from typing import List, Optional

def insertion_sort(arr: List[int]) -> List[int]:
 for i in range(1, len(arr)):
 key = arr[i]
 j = i - 1
 # 把所有比 key 大的元素都后移一位
 while j >= 0 and arr[j] > key:
 arr[j + 1] = arr[j]
 j -= 1
 arr[j + 1] = key
 return arr

4.3 关键点

稳定性：✓ 稳定
复杂度：最好 O(n)（已经有序）、最差 O(n²)（逆序）、平均 O(n²)
杀手锏：对近乎有序的数据极快——这就是为什么 Timsort（Python/Java 内置排序）会用它做"小块排序"（run）

五、希尔排序：插入排序的"跨度升级版"

5.1 核心思想

插入排序只能一步步挪动，效率差。希尔排序把数组按"间隔 gap“分成多个子序列，对每个子序列做插入排序；然后不断缩小 gap，重复；最后 gap=1 时退化为插入排序，但因为前面已经"基本有序"了，所以收尾很快。

5.2 Python 实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


from typing import List, Optional

def shell_sort(arr: List[int]) -> List[int]:
 n = len(arr)
 gap = n // 2
 while gap > 0:
 for i in range(gap, n):
 key = arr[i]
 j = i
 while j >= gap and arr[j - gap] > key:
 arr[j] = arr[j - gap]
 j -= gap
 arr[j] = key
 gap //= 2
 return arr

5.3 关键点

稳定性：✗ 不稳定（分组打乱了原顺序）
复杂度：平均约 O(n^1.3)，取决于 gap 序列
现状：理论价值 > 工业价值，现实中基本被快速排序/归并排序取代

六、归并排序：分治的"教科书”

6.1 核心思想

分治法：把数组从中点分成两半，分别排序后合并（merge）。合并两个有序数组是 O(n)，递归深度 O(log n)，所以总复杂度 O(n log n)。

6.2 Python 实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


from typing import List, Optional

def merge_sort(arr: List[int]) -> List[int]:
 if len(arr) <= 1:
 return arr
 mid = len(arr) // 2
 left = merge_sort(arr[:mid])
 right = merge_sort(arr[mid:])
 # 合并两个有序数组
 result, i, j = [], 0, 0
 while i < len(left) and j < len(right):
 if left[i] <= right[j]:
 result.append(left[i])
 i += 1
 else:
 result.append(right[j])
 j += 1
 result.extend(left[i:])
 result.extend(right[j:])
 return result

6.3 关键点

稳定性：✓ 稳定（合并时用 <= 而不是 <）
复杂度：始终 O(n log n)，没有最坏情况
空间：O(n)（需要额外数组）
应用：Java Arrays.sort() 对对象数组的排序、Python sorted() 内部走的就是归并的变体

七、快速排序：实战之王

7.1 核心思想

分治法：选一个"基准"（pivot），把数组分成"小于 pivot"和"大于 pivot"两部分，递归排序这两部分。平均 O(n log n)，最坏 O(n²)（pivot 选得不好）。

7.2 Python 实现（最常见的 Lomuto 分区）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


from typing import List, Optional

def quick_sort(arr: List[int], lo: int = 0, hi: Optional[int] = None) -> None:
 if hi is None:
 hi = len(arr) - 1
 if lo >= hi:
 return
 pivot = arr[hi] # 选最右元素作 pivot
 i = lo - 1
 for j in range(lo, hi):
 if arr[j] <= pivot:
 i += 1
 arr[i], arr[j] = arr[j], arr[i]
 arr[i + 1], arr[hi] = arr[hi], arr[i + 1]
 pivot_idx = i + 1
 quick_sort(arr, lo, pivot_idx - 1)
 quick_sort(arr, pivot_idx + 1, hi)

7.3 关键点

稳定性：✗ 不稳定（分区会交换相等元素）
原地性：✓ 原地（O(log n) 栈空间）
pivot 选取优化：三数取中（median-of-three）或随机 pivot 可以把最坏情况概率降到极低
现状：C/C++/Rust/Java 基础类型排序底层都用快排的变体（如 Introsort）

八、堆排序：原地 + O(n log n) 的"全能选手"

8.1 核心思想

利用二叉堆这种数据结构：先 O(n) 把数组建成大顶堆，然后不断把堆顶（最大值）换到末尾 + 下沉调整，循环 n-1 次。

8.2 Python 实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


from typing import List, Optional

def heap_sort(arr: List[int]) -> List[int]:
 n = len(arr)
 # 建堆（从最后一个非叶子节点开始下沉）
 for i in range(n // 2 - 1, -1, -1):
 sift_down(arr, i, n)

 # 排序：把堆顶换到末尾，再对前 n-1 个元素重新建堆
 for end in range(n - 1, 0, -1):
 arr[0], arr[end] = arr[end], arr[0]
 sift_down(arr, 0, end)
 return arr

def sift_down(arr: List[int], root: int, end: int) -> None:
 while True:
 child = 2 * root + 1
 if child >= end:
 break
 if child + 1 < end and arr[child] < arr[child + 1]:
 child += 1
 if arr[root] < arr[child]:
 arr[root], arr[child] = arr[child], arr[root]
 root = child
 else:
 break

8.3 关键点

稳定性：✗ 不稳定
原地性：✓ 原地（真正的 O(1) 空间）
现状：常用于"内存极其受限“的场景（如嵌入式、操作系统内核）

九、核心要点与常见坑

9.1 核心 N 点

稳定性 vs 性能取舍：归并/插入/冒泡稳定但慢（O(n²) 或 O(n) 空间）；快排/堆排/希尔快但不稳定
比较类 vs 非比较类：比较类有 O(n log n) 的理论下限；非比较类（计数/桶/基数）可以突破到 O(n)，但需要数据有特殊结构
原地性：堆排是唯一稳定原地 O(n log n) 的算法；归并需要 O(n) 额外空间
真实语言内置排序都是混合策略——Timsort（Python/Java）= 归并 + 插入 + run；Introsort（C++/Rust）= 快排 + 堆排 + 插入
“工业级默认"是快排/归并的变体，不要在生产里手写 O(n²) 排序

9.2 常见 M 个坑

冒泡忘了加 swapped 标志——失去了"已经有序就提前结束"的优化
归并合并时用 < 而不是 <=——破坏稳定性
快排的 pivot 选最左/最右 + 已排序输入——直接退化为 O(n²)，递归栈溢出风险
堆排的下沉边界写错——导致部分元素没参与调整
插入排序的内层 while 循环方向写反——会无限循环
混淆"时间复杂度"和"实际运行时间”——小数据量下 O(n²) 可能比 O(n log n) 更快（缓存友好、常数小）

十、选型速查

场景	推荐算法	理由
面试手写	冒泡/插入/快排	简单、能引出讨论
一般工业场景	用语言内置排序	Timsort/Introsort 已经是最优
内存极小 + 大数据	堆排序	唯一原地 O(n log n)
链表排序	归并排序	链表不适合随机访问，归并天然友好
数据基本有序	插入排序	几乎 O(n)
大数据 + 整数 + 范围小	计数排序/桶排序	O(n + k)
字符串/车牌等定长字段	基数排序	LSD/MSD 多轮分配

参考资料

《算法导论》第 2 章 / 第 6 章 / 第 7 章
VisuAlgo - Sorting：在线可视化各种排序
Timsort 原理：Python/Java 内置排序
Introsort 原理：C++ std::sort 内部用