4 不太好的安全双端队列 on 编程那些事儿

4.1 数据布局

Sun, 23 Aug 2026 16:06:00 +0800

原文链接: https://rust-unofficial.github.io/too-many-lists/fourth-layout.html

我们设计的关键是 RefCell 类型。RefCell 的核心是一对方法：

1
2


fn borrow(&self) -> Ref<'_, T>;
fn borrow_mut(&self) -> RefMut<'_, T>;

borrow 和 borrow_mut 的规则与 & 和 &mut 完全相同：你可以随意调用 borrow，但 borrow_mut 需要独占访问。

4.2 构建

Sun, 23 Aug 2026 16:06:00 +0800

原文链接: https://rust-unofficial.github.io/too-many-lists/fourth-building.html

好了，我们从构建链表开始。在这个新系统下这相当直接。new 仍然很简单，只需把所有字段设为 None。另外，因为代码开始变得有点臃肿，我们也把 Node 的构造函数单独拆出来：

4.3 破坏

Sun, 23 Aug 2026 16:06:00 +0800

原文链接: https://rust-unofficial.github.io/too-many-lists/fourth-breaking.html

pop_front 应该和 push_front 是同样的基本逻辑，只是反过来。我们来试试：

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


pub fn pop_front(&mut self) -> Option<T> {
 // 需要取出旧的 head，确保它是 -2
 self.head.take().map(|old_head| { // -1 old
 match old_head.borrow_mut().next.take() {
 Some(new_head) => { // -1 new
 // 没有清空链表
 new_head.borrow_mut().prev.take(); // -1 old
 self.head = Some(new_head); // +1 new
 // 总计：-2 old, +0 new
 }
 None => {
 // 清空链表
 self.tail.take(); // -1 old
 // 总计：-2 old,（没有 new）
 }
 }
 old_head.elem
 })
}

1
2
3
4
5
6
7


> cargo build

error[E0609]: no field `elem` on type `std::rc::Rc<std::cell::RefCell<fourth::Node<T>>>`
 --> src/fourth.rs:64:22
 |
64 | old_head.elem
 | ^^^^ unknown field

啊。RefCell。我猜又得 borrow_mut 了……

4.4 Peek

Sun, 23 Aug 2026 16:06:00 +0800

原文链接: https://rust-unofficial.github.io/too-many-lists/fourth-peek.html

好了，我们挺过了 push 和 pop。不骗你，中间有点情绪波动。编译期正确性真是令人上瘾。

我们来冷静一下，做点简单的：实现 peek_front。以前这总是很容易。现在应该还是很容易，对吧？

4.5 对称情况

Sun, 23 Aug 2026 16:06:00 +0800

原文链接: https://rust-unofficial.github.io/too-many-lists/fourth-symmetry.html

好了，把那些组合对称性一次性搞定。

我们只需要做一些基本的文本替换：

1
2
3


tail <-> head
next <-> prev
front -> back

哦，还要为 peek 添加 _mut 变体。

 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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


use std::cell::{Ref, RefCell, RefMut};

//..

pub fn push_back(&mut self, elem: T) {
 let new_tail = Node::new(elem);
 match self.tail.take() {
 Some(old_tail) => {
 old_tail.borrow_mut().next = Some(new_tail.clone());
 new_tail.borrow_mut().prev = Some(old_tail);
 self.tail = Some(new_tail);
 }
 None => {
 self.head = Some(new_tail.clone());
 self.tail = Some(new_tail);
 }
 }
}

pub fn pop_back(&mut self) -> Option<T> {
 self.tail.take().map(|old_tail| {
 match old_tail.borrow_mut().prev.take() {
 Some(new_tail) => {
 new_tail.borrow_mut().next.take();
 self.tail = Some(new_tail);
 }
 None => {
 self.head.take();
 }
 }
 Rc::try_unwrap(old_tail).ok().unwrap().into_inner().elem
 })
}

pub fn peek_back(&self) -> Option<Ref<T>> {
 self.tail.as_ref().map(|node| {
 Ref::map(node.borrow(), |node| &node.elem)
 })
}

pub fn peek_back_mut(&mut self) -> Option<RefMut<T>> {
 self.tail.as_ref().map(|node| {
 RefMut::map(node.borrow_mut(), |node| &mut node.elem)
 })
}

pub fn peek_front_mut(&mut self) -> Option<RefMut<T>> {
 self.head.as_ref().map(|node| {
 RefMut::map(node.borrow_mut(), |node| &mut node.elem)
 })
}

并大幅扩充我们的测试：

4.6 迭代

Sun, 23 Aug 2026 16:06:00 +0800

原文链接: https://rust-unofficial.github.io/too-many-lists/fourth-iteration.html

我们来试试迭代这货。

IntoIter

和往常一样，IntoIter 会是最容易的那个。只需包装栈并调用 pop：

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


pub struct IntoIter<T>(List<T>);

impl<T> List<T> {
 pub fn into_iter(self) -> IntoIter<T> {
 IntoIter(self)
 }
}

impl<T> Iterator for IntoIter<T> {
 type Item = T;
 fn next(&mut self) -> Option<Self::Item> {
 self.0.pop_front()
 }
}

但我们遇到了一个有趣的新情况。以前我们的链表只有一种"自然"的迭代顺序，而双端队列天生是双向的。从前到后有什么特别的？如果有人想反方向迭代呢？

4.7 最终代码

Sun, 23 Aug 2026 16:06:00 +0800

原文链接: https://rust-unofficial.github.io/too-many-lists/fourth-final.html

好了，这就是在 Rust 中实现一个 100% 安全的双向链表。实现起来是噩梦，会泄露实现细节，而且不支持若干基本操作。

但是，它确实存在。

哦，我猜它还充满了 Rc 和 RefCell 之间正确性的大量"不必要"运行时检查。我把不必要加了引号，因为它们实际上对于保证真正安全是必要的。我们遇到了几处那些检查实际上确实必要的地方。双向链表有着极其纠缠的别名和所有权故事！