6 生产级不安全双端队列 on 编程那些事儿

6.1 数据布局

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

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

我们先来研究敌人的结构。双向链表概念上很简单，但正因如此它才能欺骗、操纵你。它和我们反复见过的链表一样，只是链接是双向的。链接翻倍，邪恶也翻倍。

6.2 型变与子类型

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

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

现在把这事拖到以后再修会很烦，所以我们现在就做硬核布局。

写 unsafe Rust 集合有五匹可怕的天启骑士：

幸运的是，后两个对我们不是问题。

6.3 基本操作

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

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

好了，这是本书最烂的部分，也是我花了 7 年才写这章的原因！该快速过一遍我们已经做过 5 遍、极其无聊的东西了，而且要更啰嗦，因为每件事要做两遍，还要用 Option<NonNull<Node<T>>>！

6.4 恐慌安全

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

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

嘿，你注意到这条注释了吗：

1
2


// 注意我们不再需要折腾 `take`，
// 因为一切都是 Copy，搞砸了也没有析构函数会跑……对吧？:) 对吧？:)))

对吗？

6.5 无聊的组合

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

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

好，回到我们的常规链表节目！

先把 Drop 搞定，用 pop 就行：

1
2
3
4
5
6


impl<T> Drop for LinkedList<T> {
 fn drop(&mut self) {
 // 一直 pop 直到不得不停
 while let Some(_) = self.pop_front() { }
 }
}

还得填一堆很无聊的组合实现：front、front_mut、back、back_mut、iter、iter_mut、into_iter……

6.6 填补零散细节

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

原文链接: https://rust-unofficial.github.io/too-many-lists/sixth-random-bits.html

嘿，你说要 production-quality 的对吧？

再扔点 random gunk 进去，做个「好」集合：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


impl<T> LinkedList<T> {
 pub fn is_empty(&self) -> bool {
 self.len == 0
 }

 pub fn clear(&mut self) {
 // 看，又是 drop
 while let Some(_) = self.pop_front() { }
 }
}

现在还有一堆大家都期望的 trait 要实现：

6.7 测试

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

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

好吧，我拖了一阵子才写测试，因为嘛，我们都知道自己现在已经是 Rust 大师、不会再犯错了！而且这只是重写一个旧 crate，测试本来就有。测试嘛，你已经看过很多了。给：

6.8 Send、Sync 与编译测试

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

原文链接: https://rust-unofficial.github.io/too-many-lists/sixth-send-sync.html

好吧，其实还有一对 trait 要想，但它们很特殊。得面对 Rust 的神罗帝国：Unsafe Opt-In Built-In Traits（OIBIT）：Send 和 Sync——事实上是 opt-out、built-out（三项里对一项就算不错！）。

6.9 游标简介

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

原文链接: https://rust-unofficial.github.io/too-many-lists/sixth-cursors-intro.html

好！！！我们现在有个和 std 1.0 实现同水平的 LinkedList！当然意味着我们的 LinkedList 仍然完全没用。我们承受了用链表实现 Deque 的巨大性能代价，却没有让它真正有用的 API。

6.10 实现游标

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

原文链接: https://rust-unofficial.github.io/too-many-lists/sixth-cursors-impl.html

好，我们只搞 std 的 CursorMut，不可变版其实没意思。和最初设计一样，有个 “ghost” 元素用 None 表示链表头尾，可以「走过去」绕到另一侧。实现需要：

6.11 测试游标

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

原文链接: https://rust-unofficial.github.io/too-many-lists/sixth-cursors-testing.html

看看上一节犯了多少 horribly embarrassing mistakes！

Oh god API 和 std、旧 impl 都不同。 hastily 从两边 cobble 测试。对，从 std “borrow”：

 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
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113


 #[test]
 fn test_cursor_move_peek() {
 let mut m: LinkedList<u32> = LinkedList::new();
 m.extend([1, 2, 3, 4, 5, 6]);
 let mut cursor = m.cursor_mut();
 cursor.move_next();
 assert_eq!(cursor.current(), Some(&mut 1));
 assert_eq!(cursor.peek_next(), Some(&mut 2));
 assert_eq!(cursor.peek_prev(), None);
 assert_eq!(cursor.index(), Some(0));
 cursor.move_prev();
 assert_eq!(cursor.current(), None);
 assert_eq!(cursor.peek_next(), Some(&mut 1));
 assert_eq!(cursor.peek_prev(), Some(&mut 6));
 assert_eq!(cursor.index(), None);
 cursor.move_next();
 cursor.move_next();
 assert_eq!(cursor.current(), Some(&mut 2));
 assert_eq!(cursor.peek_next(), Some(&mut 3));
 assert_eq!(cursor.peek_prev(), Some(&mut 1));
 assert_eq!(cursor.index(), Some(1));

 let mut cursor = m.cursor_mut();
 cursor.move_prev();
 assert_eq!(cursor.current(), Some(&mut 6));
 assert_eq!(cursor.peek_next(), None);
 assert_eq!(cursor.peek_prev(), Some(&mut 5));
 assert_eq!(cursor.index(), Some(5));
 cursor.move_next();
 assert_eq!(cursor.current(), None);
 assert_eq!(cursor.peek_next(), Some(&mut 1));
 assert_eq!(cursor.peek_prev(), Some(&mut 6));
 assert_eq!(cursor.index(), None);
 cursor.move_prev();
 cursor.move_prev();
 assert_eq!(cursor.current(), Some(&mut 5));
 assert_eq!(cursor.peek_next(), Some(&mut 6));
 assert_eq!(cursor.peek_prev(), Some(&mut 4));
 assert_eq!(cursor.index(), Some(4));
 }

 #[test]
 fn test_cursor_mut_insert() {
 let mut m: LinkedList<u32> = LinkedList::new();
 m.extend([1, 2, 3, 4, 5, 6]);
 let mut cursor = m.cursor_mut();
 cursor.move_next();
 cursor.splice_before(Some(7).into_iter().collect());
 cursor.splice_after(Some(8).into_iter().collect());
 // check_links(&m);
 assert_eq!(m.iter().cloned().collect::<Vec<_>>(), &[7, 1, 8, 2, 3, 4, 5, 6]);
 let mut cursor = m.cursor_mut();
 cursor.move_next();
 cursor.move_prev();
 cursor.splice_before(Some(9).into_iter().collect());
 cursor.splice_after(Some(10).into_iter().collect());
 check_links(&m);
 assert_eq!(m.iter().cloned().collect::<Vec<_>>(), &[10, 7, 1, 8, 2, 3, 4, 5, 6, 9]);
 
 /* remove_current 未实现
 let mut cursor = m.cursor_mut();
 cursor.move_next();
 cursor.move_prev();
 assert_eq!(cursor.remove_current(), None);
 cursor.move_next();
 cursor.move_next();
 assert_eq!(cursor.remove_current(), Some(7));
 cursor.move_prev();
 cursor.move_prev();
 cursor.move_prev();
 assert_eq!(cursor.remove_current(), Some(9));
 cursor.move_next();
 assert_eq!(cursor.remove_current(), Some(10));
 check_links(&m);
 assert_eq!(m.iter().cloned().collect::<Vec<_>>(), &[1, 8, 2, 3, 4, 5, 6]);
 */

 let mut cursor = m.cursor_mut();
 cursor.move_next();
 let mut p: LinkedList<u32> = LinkedList::new();
 p.extend([100, 101, 102, 103]);
 let mut q: LinkedList<u32> = LinkedList::new();
 q.extend([200, 201, 202, 203]);
 cursor.splice_after(p);
 cursor.splice_before(q);
 check_links(&m);
 assert_eq!(
 m.iter().cloned().collect::<Vec<_>>(),
 &[200, 201, 202, 203, 1, 100, 101, 102, 103, 8, 2, 3, 4, 5, 6]
 );
 let mut cursor = m.cursor_mut();
 cursor.move_next();
 cursor.move_prev();
 let tmp = cursor.split_before();
 assert_eq!(m.into_iter().collect::<Vec<_>>(), &[]);
 m = tmp;
 let mut cursor = m.cursor_mut();
 cursor.move_next();
 cursor.move_next();
 cursor.move_next();
 cursor.move_next();
 cursor.move_next();
 cursor.move_next();
 cursor.move_next();
 let tmp = cursor.split_after();
 assert_eq!(tmp.into_iter().collect::<Vec<_>>(), &[102, 103, 8, 2, 3, 4, 5, 6]);
 check_links(&m);
 assert_eq!(m.iter().cloned().collect::<Vec<_>>(), &[200, 201, 202, 203, 1, 100, 101]);
 }

 fn check_links<T>(_list: &LinkedList<T>) {
 // 做这挺好！
 }

关键时刻！

6.12 最终代码

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

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

真不敢相信我让你坐看我从零重写 std::collections::LinkedList，还有一路上琐碎的细节和犯下的错误。

我做到了，书写完了，终于可以休息了。