Shikong/trpl-zh-cn
1
0
Fork 0
mirror of https://github.com/KaiserY/trpl-zh-cn synced 2024-11-09 08:51:18 +08:00
Code Issues Packages Projects Releases Wiki Activity
ccdf0540a3
trpl-zh-cn/docs/ch15-06-reference-cycles.html
KaiserY d465e2ff96 wip update ch12-03
2017-04-05 23:13:49 +08:00

332 lines
30 KiB
HTML
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

<!DOCTYPE HTML>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>引用循环和内存泄漏是安全的 - Rust 程序设计语言 简体中文版</title>
<meta content="text/html; charset=utf-8" http-equiv="Content-Type">
<meta name="description" content="Rust 程序设计语言 简体中文版">
<meta name="viewport" content="width=device-width, initial-scale=1">
<base href="">
<link rel="stylesheet" href="book.css">
<link href='https://fonts.googleapis.com/css?family=Open+Sans:300italic,400italic,600italic,700italic,800italic,400,300,600,700,800' rel='stylesheet' type='text/css'>
<link rel="shortcut icon" href="favicon.png">
<!-- Font Awesome -->
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.3.0/css/font-awesome.min.css">
<link rel="stylesheet" href="highlight.css">
<link rel="stylesheet" href="tomorrow-night.css">
<!-- MathJax -->
<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
<!-- Fetch JQuery from CDN but have a local fallback -->
<script src="https://code.jquery.com/jquery-2.1.4.min.js"></script>
<script>
if (typeof jQuery == 'undefined') {
document.write(unescape("%3Cscript src='jquery.js'%3E%3C/script%3E"));
}
</script>
</head>
<body class="light">
<!-- Set the theme before any content is loaded, prevents flash -->
<script type="text/javascript">
var theme = localStorage.getItem('theme');
if (theme == null) { theme = 'light'; }
$('body').removeClass().addClass(theme);
</script>
<!-- Hide / unhide sidebar before it is displayed -->
<script type="text/javascript">
var sidebar = localStorage.getItem('sidebar');
if (sidebar === "hidden") { $("html").addClass("sidebar-hidden") }
else if (sidebar === "visible") { $("html").addClass("sidebar-visible") }
</script>
<div id="sidebar" class="sidebar">
<ul class="chapter"><li><a href="ch01-00-introduction.html"><strong>1.</strong> 介绍</a></li><li><ul class="section"><li><a href="ch01-01-installation.html"><strong>1.1.</strong> 安装</a></li><li><a href="ch01-02-hello-world.html"><strong>1.2.</strong> Hello, World!</a></li></ul></li><li><a href="ch02-00-guessing-game-tutorial.html"><strong>2.</strong> 猜猜看教程</a></li><li><a href="ch03-00-common-programming-concepts.html"><strong>3.</strong> 通用编程概念</a></li><li><ul class="section"><li><a href="ch03-01-variables-and-mutability.html"><strong>3.1.</strong> 变量和可变性</a></li><li><a href="ch03-02-data-types.html"><strong>3.2.</strong> 数据类型</a></li><li><a href="ch03-03-how-functions-work.html"><strong>3.3.</strong> 函数如何工作</a></li><li><a href="ch03-04-comments.html"><strong>3.4.</strong> 注释</a></li><li><a href="ch03-05-control-flow.html"><strong>3.5.</strong> 控制流</a></li></ul></li><li><a href="ch04-00-understanding-ownership.html"><strong>4.</strong> 认识所有权</a></li><li><ul class="section"><li><a href="ch04-01-what-is-ownership.html"><strong>4.1.</strong> 什么是所有权</a></li><li><a href="ch04-02-references-and-borrowing.html"><strong>4.2.</strong> 引用 &amp; 借用</a></li><li><a href="ch04-03-slices.html"><strong>4.3.</strong> Slices</a></li></ul></li><li><a href="ch05-00-structs.html"><strong>5.</strong> 结构体</a></li><li><ul class="section"><li><a href="ch05-01-method-syntax.html"><strong>5.1.</strong> 方法语法</a></li></ul></li><li><a href="ch06-00-enums.html"><strong>6.</strong> 枚举和模式匹配</a></li><li><ul class="section"><li><a href="ch06-01-defining-an-enum.html"><strong>6.1.</strong> 定义枚举</a></li><li><a href="ch06-02-match.html"><strong>6.2.</strong> <code>match</code>控制流运算符</a></li><li><a href="ch06-03-if-let.html"><strong>6.3.</strong> <code>if let</code>简单控制流</a></li></ul></li><li><a href="ch07-00-modules.html"><strong>7.</strong> 模块</a></li><li><ul class="section"><li><a href="ch07-01-mod-and-the-filesystem.html"><strong>7.1.</strong> <code>mod</code>和文件系统</a></li><li><a href="ch07-02-controlling-visibility-with-pub.html"><strong>7.2.</strong> 使用<code>pub</code>控制可见性</a></li><li><a href="ch07-03-importing-names-with-use.html"><strong>7.3.</strong> 使用<code>use</code>导入命名</a></li></ul></li><li><a href="ch08-00-common-collections.html"><strong>8.</strong> 通用集合类型</a></li><li><ul class="section"><li><a href="ch08-01-vectors.html"><strong>8.1.</strong> vector</a></li><li><a href="ch08-02-strings.html"><strong>8.2.</strong> 字符串</a></li><li><a href="ch08-03-hash-maps.html"><strong>8.3.</strong> 哈希 map</a></li></ul></li><li><a href="ch09-00-error-handling.html"><strong>9.</strong> 错误处理</a></li><li><ul class="section"><li><a href="ch09-01-unrecoverable-errors-with-panic.html"><strong>9.1.</strong> <code>panic!</code>与不可恢复的错误</a></li><li><a href="ch09-02-recoverable-errors-with-result.html"><strong>9.2.</strong> <code>Result</code>与可恢复的错误</a></li><li><a href="ch09-03-to-panic-or-not-to-panic.html"><strong>9.3.</strong> <code>panic!</code>还是不<code>panic!</code></a></li></ul></li><li><a href="ch10-00-generics.html"><strong>10.</strong> 泛型、trait 和生命周期</a></li><li><ul class="section"><li><a href="ch10-01-syntax.html"><strong>10.1.</strong> 泛型数据类型</a></li><li><a href="ch10-02-traits.html"><strong>10.2.</strong> trait：定义共享的行为</a></li><li><a href="ch10-03-lifetime-syntax.html"><strong>10.3.</strong> 生命周期与引用有效性</a></li></ul></li><li><a href="ch11-00-testing.html"><strong>11.</strong> 测试</a></li><li><ul class="section"><li><a href="ch11-01-writing-tests.html"><strong>11.1.</strong> 编写测试</a></li><li><a href="ch11-02-running-tests.html"><strong>11.2.</strong> 运行测试</a></li><li><a href="ch11-03-test-organization.html"><strong>11.3.</strong> 测试的组织结构</a></li></ul></li><li><a href="ch12-00-an-io-project.html"><strong>12.</strong> 一个 I/O 项目</a></li><li><ul class="section"><li><a href="ch12-01-accepting-command-line-arguments.html"><strong>12.1.</strong> 接受命令行参数</a></li><li><a href="ch12-02-reading-a-file.html"><strong>12.2.</strong> 读取文件</a></li><li><a href="ch12-03-improving-error-handling-and-modularity.html"><strong>12.3.</strong> 增强错误处理和模块化</a></li><li><a href="ch12-04-testing-the-librarys-functionality.html"><strong>12.4.</strong> 测试库的功能</a></li><li><a href="ch12-05-working-with-environment-variables.html"><strong>12.5.</strong> 处理环境变量</a></li><li><a href="ch12-06-writing-to-stderr-instead-of-stdout.html"><strong>12.6.</strong> 输出到<code>stderr</code>而不是<code>stdout</code></a></li></ul></li><li><a href="ch13-00-functional-features.html"><strong>13.</strong> Rust 中的函数式语言功能</a></li><li><ul class="section"><li><a href="ch13-01-closures.html"><strong>13.1.</strong> 闭包</a></li><li><a href="ch13-02-iterators.html"><strong>13.2.</strong> 迭代器</a></li><li><a href="ch13-03-improving-our-io-project.html"><strong>13.3.</strong> 改进 I/O 项目</a></li><li><a href="ch13-04-performance.html"><strong>13.4.</strong> 性能</a></li></ul></li><li><a href="ch14-00-more-about-cargo.html"><strong>14.</strong> 更多关于 Cargo 和 Crates.io</a></li><li><ul class="section"><li><a href="ch14-01-release-profiles.html"><strong>14.1.</strong> 发布配置</a></li><li><a href="ch14-02-publishing-to-crates-io.html"><strong>14.2.</strong> 将 crate 发布到 Crates.io</a></li><li><a href="ch14-03-cargo-workspaces.html"><strong>14.3.</strong> Cargo 工作空间</a></li><li><a href="ch14-04-installing-binaries.html"><strong>14.4.</strong> 使用<code>cargo install</code>从 Crates.io 安装文件</a></li><li><a href="ch14-05-extending-cargo.html"><strong>14.5.</strong> Cargo 自定义扩展命令</a></li></ul></li><li><a href="ch15-00-smart-pointers.html"><strong>15.</strong> 智能指针</a></li><li><ul class="section"><li><a href="ch15-01-box.html"><strong>15.1.</strong> <code>Box&lt;T&gt;</code>用于已知大小的堆上数据</a></li><li><a href="ch15-02-deref.html"><strong>15.2.</strong> <code>Deref</code> Trait 允许通过引用访问数据</a></li><li><a href="ch15-03-drop.html"><strong>15.3.</strong> <code>Drop</code> Trait 运行清理代码</a></li><li><a href="ch15-04-rc.html"><strong>15.4.</strong> <code>Rc&lt;T&gt;</code> 引用计数智能指针</a></li><li><a href="ch15-05-interior-mutability.html"><strong>15.5.</strong> <code>RefCell&lt;T&gt;</code>和内部可变性模式</a></li><li><a href="ch15-06-reference-cycles.html" class="active"><strong>15.6.</strong> 引用循环和内存泄漏是安全的</a></li></ul></li><li><a href="ch16-00-concurrency.html"><strong>16.</strong> 无畏并发</a></li><li><ul class="section"><li><a href="ch16-01-threads.html"><strong>16.1.</strong> 线程</a></li><li><a href="ch16-02-message-passing.html"><strong>16.2.</strong> 消息传递</a></li><li><a href="ch16-03-shared-state.html"><strong>16.3.</strong> 共享状态</a></li><li><a href="ch16-04-extensible-concurrency-sync-and-send.html"><strong>16.4.</strong> 可扩展的并发：<code>Sync</code>和<code>Send</code></a></li></ul></li><li><a href="ch17-00-oop.html"><strong>17.</strong> 面向对象</a></li><li><ul class="section"><li><a href="ch17-01-what-is-oo.html"><strong>17.1.</strong> 什么是面向对象</a></li></ul></li></ul>
</div>
<div id="page-wrapper" class="page-wrapper">
<div class="page">
<div id="menu-bar" class="menu-bar">
<div class="left-buttons">
<i id="sidebar-toggle" class="fa fa-bars"></i>
<i id="theme-toggle" class="fa fa-paint-brush"></i>
</div>
<h1 class="menu-title">Rust 程序设计语言 简体中文版</h1>
<div class="right-buttons">
<i id="print-button" class="fa fa-print" title="Print this book"></i>
</div>
</div>
<div id="content" class="content">
<a class="header" href="#引用循环和内存泄漏是安全的" name="引用循环和内存泄漏是安全的"><h2>引用循环和内存泄漏是安全的</h2></a>
<blockquote>
<p><a href="https://github.com/rust-lang/book/blob/master/second-edition/src/ch15-06-reference-cycles.md">ch15-06-reference-cycles.md</a>
<br>
commit c49e5ee8859f8eb8f8867cbeafbdf5b802aa5894</p>
</blockquote>
<p>我们讨论过 Rust 做出的一些保证，例如永远也不会遇到一个空值，而且数据竞争也会在编译时被阻止。Rust 的内存安全保证也使其更难以制造从不被清理的内存，这被称为<strong>内存泄露</strong>。然而 Rust 并不是<strong>不可能</strong>出现内存泄漏，避免内存泄露<strong>并</strong>不是 Rust 的保证之一。换句话说，内存泄露是安全的。</p>
<p>在使用<code>Rc&lt;T&gt;</code>和<code>RefCell&lt;T&gt;</code>时，有可能创建循环引用，这时各个项相互引用并形成环。这是不好的因为每一项的引用计数将永远也到不了 0，其值也永远也不会被丢弃。让我们看看这是如何发生的以及如何避免它。</p>
<p>在列表 15-16 中，我们将使用列表 15-5 中<code>List</code>定义的另一个变体。我们将回到储存<code>i32</code>值作为<code>Cons</code>成员的第一个元素。现在<code>Cons</code>成员的第二个元素是<code>RefCell&lt;Rc&lt;List&gt;&gt;</code>：这时就不能修改<code>i32</code>值了，但是能够修改<code>Cons</code>成员指向的哪个<code>List</code>。还需要增加一个<code>tail</code>方法来方便我们在拥有一个<code>Cons</code>成员时访问第二个项：</p>
<p><span class="filename">Filename: src/main.rs</span></p>
<pre><code class="language-rust,ignore">#[derive(Debug)]
enum List {
Cons(i32, RefCell&lt;Rc&lt;List&gt;&gt;),
Nil,
}
impl List {
fn tail(&amp;self) -&gt; Option&lt;&amp;RefCell&lt;Rc&lt;List&gt;&gt;&gt; {
match *self {
Cons(_, ref item) =&gt; Some(item),
Nil =&gt; None,
}
}
}
</code></pre>
<p><span class="caption">Listing 15-16: A cons list definition that holds a
<code>RefCell</code> so that we can modify what a <code>Cons</code> variant is referring to</span></p>
<p>接下来，在列表 15-17 中，我们将在变量<code>a</code>中创建一个<code>List</code>值，其内部是一个<code>5, Nil</code>的列表。接着在变量<code>b</code>创建一个值 10 和指向<code>a</code>中列表的<code>List</code>值。最后修改<code>a</code>指向<code>b</code>而不是<code>Nil</code>，这会创建一个循环：</p>
<p><span class="filename">Filename: src/main.rs</span></p>
<pre><code class="language-rust"># #[derive(Debug)]
# enum List {
# Cons(i32, RefCell&lt;Rc&lt;List&gt;&gt;),
# Nil,
# }
#
# impl List {
# fn tail(&amp;self) -&gt; Option&lt;&amp;RefCell&lt;Rc&lt;List&gt;&gt;&gt; {
# match *self {
# Cons(_, ref item) =&gt; Some(item),
# Nil =&gt; None,
# }
# }
# }
#
use List::{Cons, Nil};
use std::rc::Rc;
use std::cell::RefCell;
fn main() {
let a = Rc::new(Cons(5, RefCell::new(Rc::new(Nil))));
println!(&quot;a initial rc count = {}&quot;, Rc::strong_count(&amp;a));
println!(&quot;a next item = {:?}&quot;, a.tail());
let b = Rc::new(Cons(10, RefCell::new(a.clone())));
println!(&quot;a rc count after b creation = {}&quot;, Rc::strong_count(&amp;a));
println!(&quot;b initial rc count = {}&quot;, Rc::strong_count(&amp;b));
println!(&quot;b next item = {:?}&quot;, b.tail());
if let Some(ref link) = a.tail() {
*link.borrow_mut() = b.clone();
}
println!(&quot;b rc count after changing a = {}&quot;, Rc::strong_count(&amp;b));
println!(&quot;a rc count after changing a = {}&quot;, Rc::strong_count(&amp;a));
// Uncomment the next line to see that we have a cycle; it will
// overflow the stack
// println!(&quot;a next item = {:?}&quot;, a.tail());
}
</code></pre>
<p><span class="caption">Listing 15-17: Creating a reference cycle of two <code>List</code>
values pointing to each other</span></p>
<p>使用<code>tail</code>方法来获取<code>a</code>中<code>RefCell</code>的引用，并将其放入变量<code>link</code>中。接着对<code>RefCell</code>使用<code>borrow_mut</code>方法将其中的值从存放<code>Nil</code>值的<code>Rc</code>改为<code>b</code>中的<code>Rc</code>。这创建了一个看起来像图 15-18 所示的引用循环：</p>
<p><img alt="Reference cycle of lists" src="img/trpl15-04.svg" class="center" style="width: 50%;" /></p>
<p><span class="caption">Figure 15-18: A reference cycle of lists <code>a</code> and <code>b</code>
pointing to each other</span></p>
<p>如果你注释掉最后的<code>println!</code>，Rust 会尝试打印出<code>a</code>指向<code>b</code>指向<code>a</code>这样的循环直到栈溢出。</p>
<p>观察最后一个<code>println!</code>之前的打印结果，就会发现在将<code>a</code>改变为指向<code>b</code>之后<code>a</code>和<code>b</code>的引用计数都是 2。在<code>main</code>的结尾，Rust 首先会尝试丢弃<code>b</code>，这会使<code>Rc</code>的引用计数减一，但是这个计数是 1 而不是 0，所以<code>Rc</code>在堆上的内存不会被丢弃。它只是会永远的停留在 1 上。这个特定例子中，程序立马就结束了，所以并不是一个问题，不过如果是一个更加复杂的程序，它在这个循环中分配了很多内存并占有很长时间，这就是个问题了。这个程序会使用多于它所需要的内存，并有可能压垮系统并造成没有内存可供使用。</p>
<p>现在，如你所见，在 Rust 中创建引用循环是困难和繁琐的。但并不是不可能：避免引用循环这种形式的内存泄漏并不是 Rust 的保证之一。如果你有包含<code>Rc&lt;T&gt;</code>的<code>RefCell&lt;T&gt;</code>值或类似的嵌套结合了内部可变性和引用计数的类型，请务必小心确保你没有形成一个引用循环。在列表 15-14 的例子中，可能解决方式就是不要编写像这样可能造成引用循环的代码，因为我们希望<code>Cons</code>成员拥有他们指向的列表。</p>
<p>举例来说，对于像图这样的数据结构，为了创建父节点指向子节点的边和以相反方向从子节点指向父节点的边，有时需要创建这样的引用循环。如果一个方向拥有所有权而另一个方向没有，对于模拟这种数据关系的一种不会创建引用循环和内存泄露的方式是使用<code>Weak&lt;T&gt;</code>。接下来让我们探索一下！</p>
<a class="header" href="#避免引用循环将rct变为weakt" name="避免引用循环将rct变为weakt"><h3>避免引用循环：将<code>Rc&lt;T&gt;</code>变为<code>Weak&lt;T&gt;</code></h3></a>
<p>Rust 标准库中提供了<code>Weak&lt;T&gt;</code>，一个用于存在引用循环但只有一个方向有所有权的智能指针。我们已经展示过如何克隆<code>Rc&lt;T&gt;</code>来增加引用的<code>strong_count</code>；<code>Weak&lt;T&gt;</code>是一种引用<code>Rc&lt;T&gt;</code>但不增加<code>strong_count</code>的方式：相反它增加<code>Rc</code>引用的<code>weak_count</code>。当<code>Rc</code>离开作用域，其内部值会在<code>strong_count</code>为 0 的时候被丢弃，即便<code>weak_count</code>不为 0 。为了能够从<code>Weak&lt;T&gt;</code>中获取值，首先需要使用<code>upgrade</code>方法将其升级为<code>Option&lt;Rc&lt;T&gt;&gt;</code>。升级<code>Weak&lt;T&gt;</code>的结果在<code>Rc</code>还未被丢弃时是<code>Some</code>，而在<code>Rc</code>被丢弃时是<code>None</code>。因为<code>upgrade</code>返回一个<code>Option</code>，我们知道 Rust 会确保<code>Some</code>和<code>None</code>的情况都被处理并不会尝试使用一个无效的指针。</p>
<p>不同于列表 15-17 中每个项只知道它的下一项，加入我们需要一个树，它的项知道它的子项<strong>和</strong>父项。</p>
<p>让我们从一个叫做<code>Node</code>的存放拥有所有权的<code>i32</code>值和其子<code>Node</code>值的引用的结构体开始：</p>
<pre><code class="language-rust">use std::rc::Rc;
use std::cell::RefCell;
#[derive(Debug)]
struct Node {
value: i32,
children: RefCell&lt;Vec&lt;Rc&lt;Node&gt;&gt;&gt;,
}
</code></pre>
<p>我们希望能够<code>Node</code>拥有其子节点，同时也希望变量可以拥有每个节点以便可以直接访问他们。这就是为什么<code>Vec</code>中的项是<code>Rc&lt;Node&gt;</code>值。我们也希望能够修改其他节点的子节点，这就是为什么<code>children</code>中<code>Vec</code>被放进了<code>RefCell</code>的原因。在列表 15-19 中创建了一个叫做<code>leaf</code>的带有值 3 并没有子节点的<code>Node</code>实例，和另一个带有值 5 和以<code>leaf</code>作为子节点的实例<code>branch</code>：</p>
<p><span class="filename">Filename: src/main.rs</span></p>
<pre><code class="language-rust,ignore">fn main() {
let leaf = Rc::new(Node {
value: 3,
children: RefCell::new(vec![]),
});
let branch = Rc::new(Node {
value: 5,
children: RefCell::new(vec![leaf.clone()]),
});
}
</code></pre>
<p><span class="caption">Listing 15-19: Creating a <code>leaf</code> node and a <code>branch</code> node
where <code>branch</code> has <code>leaf</code> as one of its children but <code>leaf</code> has no reference to
<code>branch</code></span></p>
<p><code>leaf</code>中的<code>Node</code>现在有两个所有者：<code>leaf</code>和<code>branch</code>，因为我们克隆了<code>leaf</code>中的<code>Rc</code>并储存在了<code>branch</code>中。<code>branch</code>中的<code>Node</code>知道它与<code>leaf</code>相关联因为<code>branch</code>在<code>branch.children</code>中有<code>leaf</code>的引用。然而，<code>leaf</code>并不知道它与<code>branch</code>相关联，而我们希望<code>leaf</code>知道<code>branch</code>是其父节点。</p>
<p>为了做到这一点，需要在<code>Node</code>结构体定义中增加一个<code>parent</code>字段，不过<code>parent</code>的类型应该是什么呢？我们知道它不能包含<code>Rc&lt;T&gt;</code>，因为这样<code>leaf.parent</code>将会指向<code>branch</code>而<code>branch.children</code>会包含<code>leaf</code>的指针，这会形成引用循环。<code>leaf</code>和<code>branch</code>不会被丢弃因为他们总是引用对方且引用计数永远也不会是零。</p>
<p>所以在<code>parent</code>的类型中是使用<code>Weak&lt;T&gt;</code>而不是<code>Rc</code>，具体来说是<code>RefCell&lt;Weak&lt;Node&gt;&gt;</code>：</p>
<p><span class="filename">Filename: src/main.rs</span></p>
<pre><code class="language-rust">use std::rc::{Rc, Weak};
use std::cell::RefCell;
#[derive(Debug)]
struct Node {
value: i32,
parent: RefCell&lt;Weak&lt;Node&gt;&gt;,
children: RefCell&lt;Vec&lt;Rc&lt;Node&gt;&gt;&gt;,
}
</code></pre>
<p>这样，一个节点就能够在拥有父节点时指向它，而并不拥有其父节点。一个父节点哪怕在拥有指向它的子节点也会被丢弃，只要是其自身也没有一个父节点就行。现在将<code>main</code>函数更新为如列表 15-20 所示：</p>
<p><span class="filename">Filename: src/main.rs</span></p>
<pre><code class="language-rust,ignore">fn main() {
let leaf = Rc::new(Node {
value: 3,
parent: RefCell::new(Weak::new()),
children: RefCell::new(vec![]),
});
println!(&quot;leaf parent = {:?}&quot;, leaf.parent.borrow().upgrade());
let branch = Rc::new(Node {
value: 5,
parent: RefCell::new(Weak::new()),
children: RefCell::new(vec![leaf.clone()]),
});
*leaf.parent.borrow_mut() = Rc::downgrade(&amp;branch);
println!(&quot;leaf parent = {:?}&quot;, leaf.parent.borrow().upgrade());
}
</code></pre>
<p><span class="caption">Listing 15-20: A <code>leaf</code> node and a <code>branch</code> node where
<code>leaf</code> has a <code>Weak</code> reference to its parent, <code>branch</code></span></p>
<p>创建<code>leaf</code>节点是类似的；因为它作为开始并没有父节点，这里创建了一个新的<code>Weak</code>引用实例。当尝试通过<code>upgrade</code>方法获取<code>leaf</code>父节点的引用时，会得到一个<code>None</code>值，如第一个<code>println!</code>输出所示：</p>
<pre><code class="language-=">leaf parent = None
</code></pre>
<p>类似的，<code>branch</code>也有一个新的<code>Weak</code>引用，因为也没有父节点。<code>leaf</code>仍然作为<code>branch</code>的一个子节点。一旦在<code>branch</code>中有了一个新的<code>Node</code>实例，就可以修改<code>leaf</code>将一个<code>branch</code>的<code>Weak</code>引用作为其父节点。这里使用了<code>leaf</code>中<code>parent</code>字段里的<code>RefCell</code>的<code>borrow_mut</code>方法，接着使用了<code>Rc::downgrade</code>函数来从<code>branch</code>中的<code>Rc</code>值创建了一个指向<code>branch</code>的<code>Weak</code>引用。</p>
<p>当再次打印出<code>leaf</code>的父节点时，这一次将会得到存放了<code>branch</code>的<code>Some</code>值。另外需要注意到这里并没有打印出类似列表 15-14 中那样最终导致栈溢出的循环：<code>Weak</code>引用仅仅打印出<code>(Weak)</code>：</p>
<pre><code>leaf parent = Some(Node { value: 5, parent: RefCell { value: (Weak) },
children: RefCell { value: [Node { value: 3, parent: RefCell { value: (Weak) },
children: RefCell { value: [] } }] } })
</code></pre>
<p>没有无限的输出（或直到栈溢出）的事实表明这里并没有引用循环。另一种证明的方式时观察调用<code>Rc::strong_count</code>和<code>Rc::weak_count</code>的值。在列表 15-21 中，创建了一个新的内部作用域并将<code>branch</code>的创建放入其中，这样可以观察<code>branch</code>被创建时和离开作用域被丢弃时发生了什么：</p>
<p><span class="filename">Filename: src/main.rs</span></p>
<pre><code class="language-rust,ignore">fn main() {
let leaf = Rc::new(Node {
value: 3,
parent: RefCell::new(Weak::new()),
children: RefCell::new(vec![]),
});
println!(
&quot;leaf strong = {}, weak = {}&quot;,
Rc::strong_count(&amp;leaf),
Rc::weak_count(&amp;leaf),
);
{
let branch = Rc::new(Node {
value: 5,
parent: RefCell::new(Weak::new()),
children: RefCell::new(vec![leaf.clone()]),
});
*leaf.parent.borrow_mut() = Rc::downgrade(&amp;branch);
println!(
&quot;branch strong = {}, weak = {}&quot;,
Rc::strong_count(&amp;branch),
Rc::weak_count(&amp;branch),
);
println!(
&quot;leaf strong = {}, weak = {}&quot;,
Rc::strong_count(&amp;leaf),
Rc::weak_count(&amp;leaf),
);
}
println!(&quot;leaf parent = {:?}&quot;, leaf.parent.borrow().upgrade());
println!(
&quot;leaf strong = {}, weak = {}&quot;,
Rc::strong_count(&amp;leaf),
Rc::weak_count(&amp;leaf),
);
}
</code></pre>
<p><span class="caption">Listing 15-21: Creating <code>branch</code> in an inner scope and
examining strong and weak reference counts of <code>leaf</code> and <code>branch</code></span></p>
<p>创建<code>leaf</code>之后，强引用计数是 1 （用于<code>leaf</code>自身）而弱引用计数是 0。在内部作用域中，在创建<code>branch</code>和关联<code>leaf</code>和<code>branch</code>之后，<code>branch</code>的强引用计数为 1（用于<code>branch</code>自身）而弱引用计数为 1（因为<code>leaf.parent</code>通过一个<code>Weak&lt;T&gt;</code>指向<code>branch</code>）。<code>leaf</code>的强引用计数为 2，因为<code>branch</code>现在有一个<code>leaf</code>克隆的<code>Rc</code>储存在<code>branch.children</code>中。<code>leaf</code>的弱引用计数仍然为 0。</p>
<p>当内部作用域结束，<code>branch</code>离开作用域，其强引用计数减少为 0，所以其<code>Node</code>被丢弃。来自<code>leaf.parent</code>的弱引用计数 1 与<code>Node</code>是否被丢弃无关，所以并没有产生内存泄露！</p>
<p>如果在内部作用域结束后尝试访问<code>leaf</code>的父节点，会像<code>leaf</code>拥有父节点之前一样得到<code>None</code>值。在程序的末尾，<code>leaf</code>的强引用计数为 1 而弱引用计数为 0，因为现在<code>leaf</code>又是唯一指向其自己的值了。</p>
<p>所有这些管理计数和值是否应该被丢弃的逻辑都通过<code>Rc</code>和<code>Weak</code>和他们的<code>Drop</code> trait 实现来控制。通过在定义中指定从子节点到父节点的关系为一个<code>Weak&lt;T&gt;</code>引用，就能够拥有父节点和子节点之间的双向引用而不会造成引用循环和内存泄露。</p>
<a class="header" href="#总结" name="总结"><h2>总结</h2></a>
<p>现在我们学习了如何选择不同类型的智能指针来选择不同的保证并与 Rust 的常规引用向取舍。<code>Box&lt;T&gt;</code>有一个已知的大小并指向分配在堆上的数据。<code>Rc&lt;T&gt;</code>记录了堆上数据的引用数量这样就可以拥有多个所有者。<code>RefCell&lt;T&gt;</code>和其内部可变性使其可以用于需要不可变类型，但希望在运行时而不是编译时检查借用规则的场景。</p>
<p>我们还介绍了提供了很多智能指针功能的 trait <code>Deref</code>和<code>Drop</code>。同时探索了形成引用循环和造成内存泄漏的可能性，以及如何使用<code>Weak&lt;T&gt;</code>避免引用循环。</p>
<p>如果本章内容引起了你的兴趣并希望现在就实现你自己的智能指针的话，请阅读 <a href="https://doc.rust-lang.org/stable/nomicon/vec.html">The Nomicon</a> 来获取更多有用的信息。</p>
<p>接下来，让我们谈谈 Rust 的并发。我们还会学习到一些新的堆并发有帮助的智能指针。</p>
</div>
<!-- Mobile navigation buttons -->
<a href="ch15-05-interior-mutability.html" class="mobile-nav-chapters previous">
<i class="fa fa-angle-left"></i>
</a>
<a href="ch16-00-concurrency.html" class="mobile-nav-chapters next">
<i class="fa fa-angle-right"></i>
</a>
</div>
<a href="ch15-05-interior-mutability.html" class="nav-chapters previous" title="You can navigate through the chapters using the arrow keys">
<i class="fa fa-angle-left"></i>
</a>
<a href="ch16-00-concurrency.html" class="nav-chapters next" title="You can navigate through the chapters using the arrow keys">
<i class="fa fa-angle-right"></i>
</a>
</div>
<!-- Local fallback for Font Awesome -->
<script>
if ($(".fa").css("font-family") !== "FontAwesome") {
$('<link rel="stylesheet" type="text/css" href="_FontAwesome/css/font-awesome.css">').prependTo('head');
}
</script>
<!-- Livereload script (if served using the cli tool) -->
<script src="highlight.js"></script>
<script src="book.js"></script>
</body>
</html>
Reference in New Issue View Git Blame Copy Permalink