写给rust初学者的教程（三）：闭包、智能指针、并发工具
这系列RUST教程一共三篇。这是最后一篇，介绍RUST语言的进阶概念。主要有闭包、智能指针、并发工具。
closure
“闭包”这个词在不少地方都有，前端有，后端有，数据库里也有。不知道美国小朋友怎么看待这个单词，反正中国的大小朋友看到这俩汉字都很懵。
Java中也有类似的概念，直接就叫“ lambda 表达式”。rust 中的闭包和 Java 的 lambda 表达式就是一个东西，所以这里演示几个例子就好了。
Java 中的函数式编程定义了一组函数式接口，rust 也类似，有三个常用的：Fn, FnOnce, FnMut，不是和参数个数或是否有返回值有关，而是分别对应的是借用引用类型、值类型、可变引用类型。你可以看一下它们的源码，只有self参数的修饰符有差异。
使用上的区别更关键。比如用
FnOnce，调用一次闭包后闭包对象就被销毁了。一般创建新线程需要用到这种特征。
给BigInteger增加一个方法：
impl BigInteger {
pub fn act_fn<A: FnMut(u8)>(&self, mut a: A) {
for d in self { // 我给BigInteger实现了IntoIterator，所以可以直接for。你可以自己搜索一下如何实现尝试尝试。如果有困难，就给self.data循环也行，但顺序会是反的。
a(d)
}
}
}
这个方法接收一个A类型的参数，A需要是FnMut 的一个实现类。变量名是a，实际上就是一个函数，所以下面我们直接给它加括号，跟javascript的闭包一样，把整数的每一位传给它。
传给它以后，它会干啥？这就是需要调用的时候指定了。
在main函数中写一个看一下：
// 定义一个BigInteger类型的变量big_int
big_int.act_fn(|d| { println!("{}", d);});//只有一个表达式时大括号可以省略
这里就是把每一位打印出来。如果要把位置也打出来，就定义一个索引变量：
let mut i = 0;
int.act_fn(|d| {
println!("{} : {}", i, d);
i = i + 1;
});
如果你第一次接触闭包或Lambda表达式，可能疑惑这个
|d|到底是什么东西。这个要看方法的实现，把什么传给了闭包。上面我们写了个for循环调用了a(d)，所以这里的d就传给了闭包去用。他们的名字不需要一样。
下面看两个对集合（对应 Java 中的 Stream ）操作的例子。
map, filter, for_each, collect
- 对集合每个元素进行操作并过滤
fn inc_vec(vec: &Vec<i32>, off: i32, threshold: i32) {
vec.iter().map(|d| d+off).filter(|d| *d>= threshold).for_each(|d| println!("{}", d));
}
这个例子最简单，我就不解释了。
- 对集合处理后再收集
fn inc_vec(vec: &Vec<i32>, off: i32, threshold: i32) -> Vec<i32> {
vec.iter().map(|d| d+off).filter(|d| *d>= threshold).collect::<Vec<i32>>()
}
这个也简单。
rust 也跟JS一样提供了方法获取索引和值，就是enumerate。
enumerate
for (i, t) in vec.iter().enumerate() {
println!("索引是 {}，值是 {}", i, t);
}
或者
vec.iter().enumerate().for_each(|i| println!("{} {}", i.0, i.1));
很多年前，闭包最诱人的地方是实现“回调”。当时Java实现不了，坐山头上哭了好几年（现在也没正经实现出来）。现在我们来看看回调。它的写法不太简单，我们一步一步修正。
先写一个类来存储回调的闭包，所以大概写成了这样：
pub struct ClosureStorage<F: FnMut(i32)> {
callbacks: Vec<F>,
}
上面定义了一个泛型参数F，并要求其是闭包，接受整数i32参数。里面定义了一个字段callbacks，是集合类型。这样我们可以往里面添加几个闭包。
这样写的问题是啥？把泛型定义在顶层的话，我们在使用的时候就会确定下来泛型类型是谁。也就是说，如果两次传入闭包的话（往callbacks字段里放），rust会认为它们的类型不同，不都是F。类似于这样
上面一句说已经推定了泛型类型是那一大串，下面说又传入了其他类型。因为是匿名类，每次的类型都不一样。
很容易，我们会想到这样改：
pub struct ClosureStorage {
callbacks: Vec<FnMut(i32)> //❎ 编译不了
}
这样会直接报错，说使用trait类型必须加上dyn关键字。rust和Java有些区别，新版的rust（应该是从1.57开始），任何使用trait定义参数类型的（而不是使用具体类型）都必须加上dyn。dyn是单词“动态”dynamic的缩写，表示这是一个动态引用，因为它实际上是啥类型要运行时才知道。
pub struct ClosureStorage {
callbacks: Vec<dyn FnMut(i32)>
}
但是这样编译还是报错，类似于“doesn't have a size known at compile-time”。因为多方面的考虑，大多时候rust要求必须提前知道对象要占据多大的内存。但是目前这样并不能知道FnMut将来的实现会是多大的，那Vec在创建的时候该申请多大空间呢？和生存期一样，内存大小也是对象的内禀、默认、强制的要求，多数情况下编译器能够推断出来。推断不出来就报错了。
那我们怎么把“现在还不确定，将来才能知道大小的”FnMut(i32)的实现放进集合里呢？rust也提供了一种类似C++的“智能指针”机制，称为“盒”。
Box
放进Box的对象会被Box拿走所有权，所以他们生存期默认是一样的。Box是一个引用，它指向动态创建的对象空间，这样对象的大小就无关紧要了，因为我们加到集合里的是Box：
pub struct ClosureStorage {
callbacks: Vec<Box<dyn FnMut(i32)>>,
}
注意
Box的泛型参数中依然需要使用dyn
然后实现添加和使用回调的方法：
impl ClosureStorage {
pub fn default() -> Self {
ClosureStorage { callbacks: vec![] }
}
pub fn register(&mut self, c: Box<dyn FnMut(i32)>) {
self.callbacks.push(c)
}
pub fn call(&mut self, i: i32) {
self.callbacks.iter_mut().for_each(|c| (*c)(i))
}
}
测试一下：
let mut cs = ClosureStorage::default();
cs.register(Box::new(|a| println!("第一个回调 {}", a)));
cs.call(100);
cs.register(Box::new(|a| println!("第2个回调 {}", a)));
cs.call(200);
cs.call(300);
这个比较简单，你先想一个这个输出是啥样的，然后自己跑一遍看看符合你的预期吗。
闭包有一个能力上面忘记说了，就是可以使用外部对象。看这段代码， 我在第8行定义了一个i：
let mut cs = ClosureStorage::default();
cs.register(Box::new(|a| println!("第一个回调 {}", a)));
cs.call(100);
cs.register(Box::new(|a| println!("第2个回调 {}", a)));
cs.call(200);
{
let mut i = 0;
cs.register(Box::new(move |b| {
i = i + 1;
println!("第三个回调 {} {}", i, b)
}));
}
cs.call(300);
cs.call(400);
打印结果：
第一个回调 100
第一个回调 200
第2个回调 200
第一个回调 300
第2个回调 300
第三个回调 1 300
第一个回调 400
第2个回调 400
第三个回调 2 400
看第三个回调的第二段输出，这里打印了i，300的时候打印了1，400的时候打印了2。神奇不？
不知道你有没有这个疑问：为啥要传一个Box进register方法，而不是传一个闭包，在方法里面封装成Box？
当然你可能以为我是随便写的，只是没这样实现。两种应该都可以吧？
但是你真的这样写了，rust会提示你：
连IDEA也说还是用Box吧，看来方法的参数也需要是确定大小的类型。
可以使用泛型来实现这个思路，因为泛型类型是具体的：
pub fn register_generic<FG: FnMut(i32) + 'static>(&mut self, c: FG) {
self.callbacks.push(Box::new(c));
}
这里我们传入一个闭包c，在方法体里面进行了Box封装。c的类型FG的边界是FnMut(i32) + 'static。'static是rust中一个保留的生存期变量，表示和整个程序相同。为什么要加上这个约束呢？因为闭包是延迟执行的，如果不延迟对象的生存期，等到执行的时候发现里面有引用的对象已经失效了不就是重大bug了吗。
再测试一下：
{
let mut i = 0;
cs.register(Box::new(move |b| {
i = i + 1;
println!("第三个回调 {} {}", i, b)
}));
cs.register_generic(move |b| {
i = i + 1;
println!("第si个回调 {} {}", i, b)
});
}
cs.call(300);
cs.call(400);
你猜一下现在的输出是什么？尤其是变量i那里会打印什么？我估计大概率会出乎你意料。
move
不知道你注意到没有，我们传入闭包的时候有时需要写上move。你可以删掉它看一下编译器的报错。原因和上面使用'static的原因一样，正常来讲i不会到了大括号外面还能用，因为它会被销毁。但是这样我们执行cs.call(300);时就麻烦了。所以我们需要把i move 到闭包里面，变成static的生存期。
上面的两个
register方法我们该用哪个？一般的建议是，能不用泛型就不用泛型。跟Java不同的是（Java是假泛型，“运行时擦除”），rust和c++一样，对于每个泛型实现都会生成一份代码（单态化）。所以实际上我们上面的第三和第四个回调已经产生了两份register_generic方法，而第一个和第二个回调是共享同一个方法的。
网上有人总结了它们泛型实现上的差别，我赶紧fork了一份，你可以看看：https://gist.github.com/davelet/94373606d86e108bb584359408e6bbc3
接下来你可能会问的问题是：“C++中的智能指针可不止会独享（unique_ptr），还有共享指针（shared_ptr）呢。rust的Box能共享吗？”
我们可以试一下，直接给回调类型实现Clone特征看看：
impl Clone for ClosureStorage {
fn clone(&self) -> Self {
ClosureStorage { callbacks: self.callbacks.clone() }
}
}
为什么这样就是在共享闭包了呢？因为闭包是不能克隆的，它就没提供这个能力。所以当我们克隆callbacks的时候，只是克隆了集合中的Box，指针指向的闭包还是独一份。如果Box允许我们这样做，那就说明Box可以提供共享的能力。
试了一下，真的不行！
会不会是闭包类型的关系，我们用了FnMut，改成Fn可以吗：
pub struct ClosureStorage {
callbacks: Vec<Box<dyn Fn(i32)>>,
}
显然还是不行。
实际上，rust 真的提供了共享型智能指针，叫“引用计数指针”。
Rc
引用计数（Refrence Counting， RC）指针就是为了解决我们上面提到的问题的。它是一个共享型 的智能指针，每复制一次就增加一个引用计数，释放一次就减少一个计数；当计数为0的时候，引用的对象就会被销毁。
既然是共享引用，那就不能变更了，所以只能跟Fn搭配。我们把我们前面的代码所有用到Box的地方都改成Rc试一下：
pub fn register(&mut self, c: Rc<dyn Fn(i32)>) {
self.callbacks.push(c)
}
pub fn register_generic<'a, FG: Fn(i32) + 'static>(&mut self, c: FG) {
self.callbacks.push(Rc::new(c));
}
pub fn call(&mut self, i: i32) {
self.callbacks.iter_mut().for_each(|c| c(i))
}
既然会共享（回调会被克隆），那我们之前写的外部计数变量就不能用了。你可以注释掉，然后测试一下：
{
let mut i = 0;
cs.register(Rc::new(move |b| {
// i = i + 1;
println!("第三个回调 {} {}", i, b)
}));
cs.register_generic(move |b| {
// i = i + 1;
println!("第si个回调 {} {}", i, b)
});
}
cs.call(300);
cs.clone().call(400); // 注意这里的clone
没问题，正常输出。然后可能有人大喊一声“虽然，但是”。好的明白，你想说你的需求就是要打印出回调次数，去掉外部变量可咋办啊？！
没关系，我敢猜你的想法就敢给方案。rust 也提供了类似原子类的东西，你听到这仨字立马就明白了吧。
Cell
rust 的“原子类”叫 Cell，也是接受一个泛型参数，表示引用的什么类型的数据。我们把外部变量改一下：
{
let mut i: Cell<i32> = Cell::new(0);
cs.register(Rc::new(move |b| {
i.set(i.get() + 1);
println!("第三个回调 {} {}", i.get(), b)
}));
i = Cell::new(0);
cs.register_generic(move |b| {
i.set(i.get() + 1);
println!("第si个回调 {} {}", i.get(), b)
});
}
cs.call(300);
cs.clone().call(400);
Cell 提供两个方法：
get, 用来获取其中的数据拷贝，注意是Copy不是引用也不是克隆，所以要求泛型类必须支持Copyset, 用来以内存安全的方式更新内存的数据
测试可证明，cs.clone()和 Cell 可以共同使用。
这不搞呢吗？前面斩钉截铁说“别名和修改势同水火”，还说什么“铁律”，这才几分钟就打破“铁律”了！
这里面涉及一个概念“内部可变性”（interior mutability）。简单说就是rust认为共享后修改数据如果影响了其他共享者是不可以的，但是如果能够判断出来共享后的修改依然安全，就允许修改。哈！
可能还有人说：天啦撸，Cell 还有这好处呢？那我直接把回调放到Cell里不就好了，还用担心这担心那的吗？
太聪明了，我咋没想到。我们一起来试试。
又有人说：你不是刚说Cell的泛型参数需要是Copy Type吗，闭包是可以Copy的吗？
对啊，闭包还真不能被拷贝。可是我跟大家一样不想放弃使用Cell。好在rust提供了另一个实现内部可变性的类型。
RefCell
Cell 返回的是数据的拷贝，而RefCell 顾名思义返回的是数据的引用，它不需要数据是拷贝类型。
天啦撸，你这样说那我再也不用
Cell了可，反正一招RefCell吃漫天。呃，目前来说你可以这样理解，随着对rust越来越了解，你会明白他们的使用场景的。RefCell更笨重，使用不当还会引发运行时才能发现的错误。
pub struct ClosureStorage {
callbacks: Vec<Rc<RefCell<dyn FnMut(i32)>>>,
}
回调集合被改版成上面这样了：又加了一层指针，尖括号都三层了。相应的，再去改改方法实现。这次我太懒了，只保留一个泛型注册方法：
pub fn register<'a, FG: FnMut(i32) + 'static>(&mut self, c: FG) {
self.callbacks.push(Rc::new(RefCell::new(c)));
//这里没啥说是的，就是又new了一层
}
pub fn call(&mut self, i: i32) {
self.callbacks.iter().map(|c| c.borrow_mut()).for_each(|mut c| (&mut *c)(i))
}
我们重点看call方法。对于每个回调的封装RefCell，可以调用其borrow或borrow_mut方法拿到其数据的借用引用或可变引用，然后将其以闭包形式调用。这里拿到的是可变引用（是另一种智能指针RefMut类型的引用）。调用时我写的是(&mut *c)(i)，但那些修饰都可以省略。你写成(&mut c)(i)甚至c(i)都是可以的。
看一下测试代码：
{
let mut i = 0;
cs.register(move |b| {
i = i + 1;
println!("第三个回调 {} {}", i, b)
});
cs.register(move |b| {
i = i + 1;
println!("第si个回调 {} {}", i, b)
});
}
cs.call(300);
cs.clone().call(400);
我们又开心得使用克隆了而且不用使用Cell了。
RefCell没有get和set方法，而是get_mut和replace。
好了，现在可以再休息一下了。
但是可能有人不想休息说：“哎，都走到这里了，原子类都说了，还不说并发吗？”好吧，本来这篇文章我不想写并发的，毕竟篇幅已经挺长了。不过既然大家这样说了，马上安排！
thread
可以通过spawn 函数创建一个新线程：
thread::spawn(|| {
print!("我在新线程")
});
thread是一个模块，spawn 是里面的一个静态函数。
上手线程的入门例子一般是生产者消费者，我们来写一下。
假设流水线上生产产品，生产好了会放到仓库。仓库大小是10，满了就不能再生产了。消费者每次拿走一个产品去处理，没的拿了就得等着。流水线下班的时候会给最后一件产品挂上打烊的牌子。消费者看到牌子就知道后面不会再生产了，他就也去休息了。
我们这里让生产者读取一个文件，每一行就是一个产品，直到读完；消费者按行消费，对所有行进行排序后结束。
use std::fs::File;
use std::io::{BufRead, BufReader};
use std::sync::mpsc::{Receiver, sync_channel, SyncSender};
use std::thread;
fn produce(file: String, channel: SyncSender<String>) {
let file = File::open(file);
match file {
Ok(file) => {
let file = BufReader::new(file);
for line in file.lines() {
match line {
Ok(line) => {
let send_rs = channel.send(line.clone());
match send_rs {
Ok(ok) => {}
Err(err) => { println!("sent line err :{}", err) }
}
}
Err(err) => { println!("read line err :{}", err) }
}
}
}
Err(err) => { println!("read file err: {}", err) }
}
}
fn consume(channel: Receiver<String>) {
let mut vec: Vec<String> = channel.iter().collect();
vec.sort();
for (i, line) in vec.iter().enumerate() {
println!("{}: {}", i, line)
}
}
这里有两个函数，一个用来生产，一个用来消费。生产者需要告诉它读取哪个文件，同时把读取数据发出去。因为我们上面说仓库有大小，所以这里使用了同步队列。生产者需要用到一个SyncSender，消费者用到Receiver，这俩是同一个队列的两头。
从代码可见，生产者调用channel.send()发到队列，消费者使用channel.iter()消费消息。那消费者怎么知道生产者停止了呢？
生产者停止后，produce函数就结束了，结束后它持有的所有权变量都会被销毁，包括channel。这时候channel会被标记为无效，消费者就停止了。
sync_channel
sync_channel 函数可以创建这个队列通道，并返回这两个变量。我们写一个测试方法看一下效果
#[test]
fn p_c() {
let file = r#"src/main.rs"#.to_string();
let (sender, receiver) = sync_channel(10);//容量是10
thread::spawn(|| produce(file, sender));
thread::spawn(|| consume(receiver));
thread::sleep(Duration::from_secs(5));// 主线程休眠几秒等待跑完
}
slice
你应该一直有个疑问：像上面这样想用字符串的时候，直接使用双引号包围为什么不够，还得to_string一下？rust中的字符串到底是什么类型：有时候好像叫String —— rust 确实内置了这个结构体类型；有时候又不得不加to_string，比如双引号包围的内容：
let file = r#"src/main.rs"#.to_string();
前面在讲Box时说过，rust 编译的时候需要明确知道对象占据的空间大小，一方面是性能一方面是安全。如果使用了unsized类型，编译器会报错。Box 是一种方案，将指针放到了堆上。rust 还提供了一种胖指针（fat pointer）方案，就是指针上面携带上对象的大小，这个称为“切片”（slice）。类型是中括号包裹着泛型类型[T]。
双引号包围的字面量是在编译时确定下来的，生存期和程序相同；使用时以字符串切片访问。String 是分配在堆上的，和其他对象一样，生存期结束后会被销毁。静态字面量转成字符串时会在堆上生成一份（就像上面刚刚），字符串转成切片也使用中括号：
let s = String::from("Hello, world!");
let slice = &s[..]; // 获取整个字符串的切片
let substr = &s[0..5]; // 获取从索引0到索引5（不包含5）的子串
String的切片是&str，Vec<T>和固定大小数组[T; n]的切片都是&mut [T]。记住，切片都是指针。
集合排序时如果用分治算法，就需要反复生成切片。我们来写一个快排看看：
fn quick_sort<T: PartialOrd>(list: &mut [T]) {
if list.len() < 2 { return; } // 递归出口
let mut lpos = 1;
let mut rpos = list.len() - 1;
loop {
if lpos > rpos { break; }
if list[0] >= list[lpos] {
lpos += 1
} else if list[0] < list[lpos] {
list.swap(lpos, rpos);
rpos -= 1;
}
}
list.swap(0, lpos - 1);
let parts = list.split_at_mut(lpos);
quick_sort(&mut parts.0[..lpos - 1]);
quick_sort(parts.1);
}
快排是一个递归算法，每次把集合分成三段：一段只有一个元素，称为“pivot” 基准值，每一轮结束后基准值会放到它合适的位置；第二段和第三段都可能是空的，分别是比基准值都小和大的两部分（其中一段里的值可以和基准值相等，不然有相等元素咋办）。然后分别对左右两段再次递归快排。
由于使用了泛型，所以要求元素类型必须能使用大小于号比较，就需要具备
PartialOrd特征。
逻辑我们就不看了，直接看最后三行，这里进行了切片。切片自身提供了一个方法split_at_mut来生成两个可变切片
我们把元组两个元素分别递归，不过左侧需要先把最后一个元素去掉，因为它就是基准值，已经排好序了。
你可以写个测试debug跟踪一下看看，每次这个函数的参数是啥样的，分片后又是啥样的。
现在你可以用这个函数去给上面的消费者使用一下看看效果：
// vec.sort();
sort(&mut vec[..]);
sync_channel 是我们用到的第一个线程同步工具，和其他语言一样，rust也提供了很多其他同步工具用于应对各种需求场景。现在来看一下信号量。
Mutex
假设有两个员工在生产，他们的经理在监督。产品放在公共区域，每一时刻只能有一个人访问这块区域。
没错就是“临界区”。
我们写两个线程，让他们分别去更新一个整数，主线程定期去查看整数的快照。为了锁住临界区，这里使用 Mutex。竞争的数据会放在 Mutex 里面，要访问数据只能通过 Mutex。类型就是 Mutex<usize>。不过他不是天然能被并发访问的，需要用 Rc 包裹起来引用。
Arc
线程间需要共享Rc对象的话，由于是多线程，引用计数在更新的时候可能会混乱。rust 提供了线程安全版本的Rc，叫 Arc。Arc 会以原子操作方式更新引用计数。
当然了，如果你坚持不用
Arc就是要用Rc也是……不行的，rust能发现你的错误并报错
为了给共用整数增加方法，我们封装一个类型。
以前我们总是用struct搭配大括号，其实还可以搭配小括号。
tuple struct
因为小括号是元组，所以这种方式称为“元组结构体”。跟结构体的区别是不用声明字段名，只要写类型就行。使用的时候是按照字段顺序访问：
#[derive(Clone)]
pub struct AtomicIncrement(Arc<Mutex<usize>>);
impl AtomicIncrement {
pub fn new(value: usize) -> Self {
AtomicIncrement(Arc::new(Mutex::new(value)))
}
pub fn inc(&self, step: usize) {
let lock = self.0.lock(); // 使用`.0`拿到字段
match lock {
Ok(mut int) => { *int = *int + step }
Err(err) => { println!("{}", err) }
}
}
pub fn get(&self) -> usize {
*self.0.lock().unwrap()
// *self.0.lock().unwrap_or_else(|e| { e.into_inner() }) // 这是干啥？在 IDE 中看一下过程变量是什么类型
}
}
这里提供了两个方法，我相信你能理解其中逻辑。
测试一下：
#[test]
fn increment() {
let atomic = AtomicIncrement::new(0);
let a1 = atomic.clone();
thread::spawn(move || {
for _ in 0..10 {// 一个线程跑200毫秒，给整数增加20
thread::sleep(Duration::from_millis(20));
a1.inc(2);
}
});
let a2 = atomic.clone();
thread::spawn(move || {
for _ in 0..40 {// 另一个线程跑1200毫秒，给整数增加40
thread::sleep(Duration::from_millis(30));
a2.inc(1);
}
});
for i in 0..30 {// 主线程每50毫秒输出一次，最后应该稳定到60
thread::sleep(Duration::from_millis(50));
println!("{}: {}", i, atomic.get());
}
}
你自己给
AtomicIncrement写一个cas方法测试一下，如果你知道CAS的工作流程的话。
这个工作逻辑不知道你满意吗？为什么读写都用同一把锁，连rust自身的借用引用都不是这样的。
当然，rust提供了增强版本 —— 读写锁，来区分共享和排他。
RwLock
简单场景下，这个同步工具在用法上和Mutex几乎完全一样。所以我不重新写一遍了，这次你来吧。
把Arc<Mutex<usize>>改成Arc<RwLock<usize>> 就行。获取读锁使用read方法，获取写锁使用write方法。
现在有些人可能又会有天大的问题了：你都使用RwLock代替Mutex了，竟然不用原子类？你上面不是说rust有原子类吗？干啥不用，Cell行不行，不行给你个RefCell！
rust 为了防止我们不合时宜的在多线程环境传递对象，提供了两个标记特征：Send和Sync。也许你在我们刚使用spawn函数时看到过这个东西
Send标记一个对象可以在线程间安全的传递（传递后还是只有一个线程在用），Sync 标记一个对象的引用可以被多个线程安全的访问。所以一个类型如果实现了Sync，那它的借用引用就具备了Send特征，可以在多个线程间传递（反之也有同样的要求）。而一个类型实现了Send，则它的可变引用也就具备了Send（反之也有同样的要求）。一个类型自身是Send或者Sync要求它的成员字段也是这样的。
你可以看一下源码，Arc是实现了这个特征的
而Cell和RefCell是实现了Send但是没有Sync的
回到我们的问题，我们要共享Arc<T>，这是一个共享引用，按照上面说的限制，就要求T是可Sync的。所以不能使用RefCell:
文章的最后强调一点：rust 中是没有原生的 null 或者 nil 这种关键字的。但是经常在我们逻辑中需要使用一个空对象，有哪些方法呢？
用的最多的当然是Option<T>了，或者有些时候使用Result<T>在语义上可能更好。但是如果不想使用封装对象，就需要使用原始指针了。这是rust的unsafe，所以能不用尽量不用。
好了，全文结束。
如果你之前没能自己给BigInteger实现迭代能力，可以参考下面的代码：
impl BigInteger {
pub fn iter(&self) -> DigitIter {
DigitIter::default(self)
}
}
impl<'a, 'b> IntoIterator for &'a BigInteger {
type Item = u8;
type IntoIter = DigitIter<'a>;
fn into_iter(self) -> Self::IntoIter {
self.iter()
}
}
pub struct DigitIter<'a> {
int: &'a BigInteger,
size: usize,
}
impl<'a> DigitIter<'a> {
pub fn default(b: &'a BigInteger) -> Self {
DigitIter { int: b, size: b.data.len() }
}
}
impl<'a> Iterator for DigitIter<'a> {
type Item = u8;
fn next(&mut self) -> Option<Self::Item> {
if self.size == 0 {
None
} else {
self.size = self.size - 1;
Some(self.int.data[self.size])
}
}
}
