std::io::Stdout::lock() 去确保输出没有被中断。println!() 将等待直到任意并发地运行完成后，在写入输出。如果不是这样，我们可以得到更多的交叉输出：
+ println 宏使用 std::io::Stdout::lock() 去确保输出没有被中断。println!() 表达式将等待直到任意并发的表达式运行完成后，再写入输出。如果不是这样，我们可能得到更多的交错输出：
Hello fromHello from another thread! @@ -107,7 +107,7 @@ This is my thread id: ThreadId(3) id: ThreadId(3)
std::thread::Builder 允许你在产生线程之前为新线程设置一些设置。你可以使用它为新线程配置栈大小并给新线程一个名字。线程的名字是可以通过 std::thread::current().name() 获得，这将在 panic 消息中可用，并在监控和大多数雕饰工具中可见。
此外，Builder 的产生函数返回一个 std::io::Result，允许你处理新线程失败的情况。如果操作系统内存不足，或者资源限制已经应用于你对程序，这是可能发生的。如果 std::thread::spawn 函数不能去产生一个新线程，它只会 panic。
此外，Builder 的产生函数返回一个 std::io::Result，允许你处理产生新线程失败的情况。如果操作系统内存不足，或者资源限制已经应用于你的程序，这是可能发生的。如果 std::thread::spawn 函数不能去产生一个新线程，它就会 panic。
在 Rust 1.0 之前，标准库有一个函数叫做 std::thread::scoped，它将直接产生一个线程，就像 std::thread::spawn。它允许无 'static 的捕获，因为它返回的不是 JoinGuard，而是当被 drop 时 join 到线程的 JoinGuard。任意的借用数据仅需要比这个 JoinGuard 活得更久。只要 JoinGuard 在某个时候被 drop，这似乎是安全的。
在 Rust 1.0 之前，标准库有一个函数叫做 std::thread::scoped，它将直接产生一个线程，就像 std::thread::spawn。它允许无 'static 的捕获，因为它返回的不是 JoinHandle，而是当被 drop 时 join 到线程的 JoinGuard。任意的借用数据仅需要比这个 JoinGuard 活得更久。只要 JoinGuard 在某个时候被 drop，这似乎是安全的。
就在 Rust 1.0 发布之前，人们慢慢发现它似乎不能保证某些东西被 drop。有很多种方式没有 drop 它，例如创建一个引用计数节点的循环，可以忘记某些东西或者*泄漏*它。
@@ -226,11 +226,11 @@ error[E0499]: cannot borrow `numbers` as mutable more than once at a time ## 共享所有权以及引用计数 -目前，我们已经使用了 `move` 闭包（[“Rust 中的线程”](#rust-中的线程)）将值的所有权转移到线程并从生命周期较长的父线程借用数据（[“线程作用域”](#线程作用域)）。当两个线程之间共享数据，它们之间的任何一个线程都不能保证比另一个线程的生命周期长，那么它们都不能称为该数据的所有者。它们之间共享的任何数据都需要与最长生命周期的线程一样长。 +目前，我们已经使用了 `move` 闭包（[“Rust 中的线程”](#rust-中的线程)）将值的所有权转移到线程并从生命周期较长的父线程借用数据（[作用域内的线程](#作用域内的线程)）。当两个线程之间共享数据，它们之间的任何一个线程都不能保证比另一个线程的生命周期长，那么它们都不能称为该数据的所有者。它们之间共享的任何数据都需要与最长生命周期的线程一样长。 ### Static -有几种方式去创建不属于单线程的东西。最简单的方式是**静态**值，它由整个程序“拥有”，而不是单个线程。在以下示例中，这两个线程都可以获取 X，但是它们并不能拥有它： +有几种方式去创建不属于单线程的东西。最简单的方式是**静态**值，它由整个程序“拥有”，而不是单个线程。在以下示例中，这两个线程都可以获取 X，但是它们并不拥有它： ```rust static X: [i32; 3] = [1, 2, 3]; @@ -262,7 +262,7 @@ thread::spawn(move || dbg!(x)); ### 引用计数 -为了确保共享数据能够 drop 和取消分配，我们不能完全放弃它的所有权。相反，我们可以*分享所有权*。通过跟踪所有者的数量，我们确保仅当没有所有者时，才会丢弃该值。 +为了确保共享数据能够 drop 和释放内存，我们不能完全放弃它的所有权。相反，我们可以*分享所有权*。通过跟踪所有者的数量，我们确保仅当没有所有者时，才会丢弃该值。 Rust 标准库通过 `std::rc::Rc` 类型提供了该功能，它是“引用计数”（reference counted）的缩写。它与 `Box` 非常类似，唯一的区别是克隆它将不会分配任何新内存，而是增加存储在包含值旁边的计数器。原始的 `Rc` 和克隆的 `Rc` 将引用相同的内存分配；它们*共享所有权*。 @@ -397,7 +397,7 @@ let b = unsafe { a.get_unchecked(index) };如果我们破坏了这个假设，例如，我们以等于 3 的索引运行，任何事情都可能发生。它可能导致读取 a 之后存储的任何内存内容。这可能导致程序崩溃。它可能会执行程序中完全无关的部分。它可能会引起各种糟糕的情况。
-或许令人惊讶的是，[未定义行为甚至可以“时间回溯”，导致之前的代码出问题](https://en.wikipedia.org/wiki/Speculative_execution)」。要理解这种情况是如何发生的，想象我们上面的片段有一个 match 语句，如下：
+或许令人惊讶的是，未定义行为甚至可以“时间回溯”，导致之前的代码出问题。要理解这种情况是如何发生的，想象我们上面的片段有一个 match 语句，如下：
match index {
0 => x(),
diff --git a/2_Atomics.md b/2_Atomics.md
index c813682..18d0340 100644
--- a/2_Atomics.md
+++ b/2_Atomics.md
@@ -108,7 +108,7 @@ fn main() {
}
```
-这次，我们使用一个[线程作用域](./1_Basic_of_Rust_Concurrency.md#线程作用域)，它将自动地为我们处理线程的 join，并且也允许我们借用局部变量。
+这次，我们使用一个[作用域内的线程](./1_Basic_of_Rust_Concurrency.md#作用域内的线程)，它将自动地为我们处理线程的 join，并且也允许我们借用局部变量。
每次后台线程完成处理项时，它都会将处理的项目数量存储在 AtomicUsize 中。与此同时，主线程向用户显示该数字，告知该进度，大约每秒一次。一旦主线程看见所有 10 项已经被处理，它就会退出作用域，它会隐式地 join 后台线程，并且告知用户所有都完成。
diff --git a/README.md b/README.md
index fadb3f8..ec6279f 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,7 @@
## [第一章：Rust 并发基础](./1_Basic_of_Rust_Concurrency.md)
* [Rust 中的线程](./1_Basic_of_Rust_Concurrency.md#rust-中的线程)
-* [线程作用域](./1_Basic_of_Rust_Concurrency.md#线程作用域)
+* [作用域内的线程](./1_Basic_of_Rust_Concurrency.md#作用域内的线程)
* [共享所有权以及引用计数](./1_Basic_of_Rust_Concurrency.md#共享所有权以及引用计数)
* [Static](./1_Basic_of_Rust_Concurrency.md#static)
* [泄漏（Leak）](./1_Basic_of_Rust_Concurrency.md#泄漏leak)