blocks|key|1318107|text|Rc没有循环集合。如果您创建了一个引用循环，那么您很可能会使程序崩溃，因为它试图增加重新计数。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1318108|虽然从技术上讲，这也是一个垃圾收集器，但它并不是一个普遍有用的工具，因为您对它可以包含的类型有限制。|1318109|entityMap^0|0|2|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|N|8|@]|D|@]|E|$]]]|I|$]]

<code>Rc</code> has no cycle collection. If you create a cycle of references, you will probably crash the program as it tries to increment the refcount.

Though this technically counts as a garbage collector too, it's not a universally useful one since you have the restriction on the types it can contain.

blocks|key|1729370|text|我认为垃圾回收是防止手动释放动态分配内存的任何进程。|type|blockquote|depth|inlineStyleRanges|entityRanges|data|1729371|那么铁锈确实有“垃圾收集”！|unstyled|1729372|fn+make_stuff()+{
++++//+Allocate+memory+on+the+heap+and+store+`true`+in+it
++++let+thing+=+Box::new(true);
++++//+Allocate+memory+on+the+heap+and+store+1000+numbers+in+it.
++++let+things+=+vec![42;+1000];
}+//+Look+Ma!+No+manual+deallocation!|code-block|syntax|javascript|1729373|当thing和things超出作用域时(在本例中，是在方法的末尾)，那么它们分配的内存将被释放给您。|offset|length|style|CODE|1729374|Rc和Arc允许更多的灵活性；您应该让他们的医生读一读才能知道更多。|1729375|除了@Manishearth的回答之外，还有以下细节(强调我的)：|1729376|在其最后一个所有者的生命周期结束时自动释放|BOLD|1729377|在许多垃圾收集语言中，垃圾收集与您的代码的其余部分无关。在“铁锈”中，将知道重新分配的地点。|1729378|考虑到这个Java：|1729379|public+static+ArrayList+alpha()
{
++++return+new+ArrayList();
}

public+static+void+beta()
{
++++alpha();+//+Unused+result
}|1729380|我不相信你能肯定地说什么时候ArrayList将从内存中删除。在等效的Rust代码中，您知道Arc或Rc一旦超出作用域就会被销毁。|1729381|entityMap|0|LINK|mutability|MUTABLE|url|http://doc.rust-lang.org/std/rc/index.html^0|0|0|0|1|5|7|6|0|0|2|3|3|J|5|0|0|0|2|C|0|0|0|0|1A|3|1E|2|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1D|8|@]|9|@]|A|$]]|$1|E|3|F|5|G|7|1E|8|@]|9|@]|A|$H|I]]|$1|J|3|K|5|D|7|1F|8|@$L|1G|M|1H|N|O]|$L|1I|M|1J|N|O]]|9|@]|A|$]]|$1|P|3|Q|5|D|7|1K|8|@$L|1L|M|1M|N|O]|$L|1N|M|1O|N|O]]|9|@$L|1P|M|1Q|1|1R]]|A|$]]|$1|R|3|S|5|D|7|1S|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|1T|8|@$L|1U|M|1V|N|V]]|9|@]|A|$]]|$1|W|3|X|5|D|7|1W|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1X|8|@]|9|@]|A|$]]|$1|10|3|11|5|G|7|1Y|8|@]|9|@]|A|$H|I]]|$1|12|3|13|5|D|7|1Z|8|@$L|20|M|21|N|O]|$L|22|M|23|N|O]]|9|@]|A|$]]|$1|14|3|-4|5|D|7|24|8|@]|9|@]|A|$]]]|15|$16|$5|17|18|19|A|$1A|1B]]]]

<blockquote>
 I consider garbage collection to be any process which prevents the need for manual deallocation of dynamically-allocated memory
</blockquote>

Then Rust does have "garbage collection"!

<pre><code>fn make_stuff() {
 // Allocate memory on the heap and store `true` in it
 let thing = Box::new(true);
 // Allocate memory on the heap and store 1000 numbers in it.
 let things = vec![42; 1000];
} // Look Ma! No manual deallocation!
</code></pre>

When <code>thing</code> and <code>things</code> go out of scope (in this case, at the end of the method), then the memory they had allocated will be freed for you.

<code>Rc</code> and <code>Arc</code> allow more flexibility than this; you should give <a href="http://doc.rust-lang.org/std/rc/index.html" rel="noreferrer">their docs</a> a read to know more.

<hr>

In addition to @Manishearth's answer, there's also this detail (emphasis mine):

<blockquote>
 automatically freed at the end of its last owner's lifetime
</blockquote>

In many garbage-collected languages, garbage collection happens out-of-band with the rest of your code. In Rust, the location of deallocation will be known.

Given this Java:

<pre><code>public static ArrayList alpha()
{
 return new ArrayList();
}

public static void beta()
{
 alpha(); // Unused result
}
</code></pre>

I do not believe that you can say with certainty when the ArrayList will be removed from memory. In the equivalent Rust code, you know that an <code>Arc</code> or <code>Rc</code> will be destructed as soon as it goes out of scope.

blocks|key|1323663|text|如果你坚持正确，垃圾收集器收集。它收集要释放的内存位置列表。另一方面，Rc/Arc没有，所以我认为你不能称之为垃圾收集。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1323664|不过铁锈有std::gc模块，所以YA锈病现在实际上是一个可选的垃圾收集器。|offset|length|style|CODE|1323665|entityMap^0|0|5|7|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

If you insist on being correct, a garbage collector collects. It collects a list of memory locations to free. Rc/Arc on the other hand does not, so I don't think you can call it garbage collection.

However rust has the <code>std::gc</code> module, so yea rust has in fact an optional garbage collector for now.

blocks|key|1729442|text|关于锈蚀现在是如何改变的，这这篇文章有点老了，但它强调了它意味着Rust没有GC。只有RAII和所有权是铁锈固有的。它们帮助编写参考资料，如Rc和Arc等GCs，但它们不是语言的一部分，它们是标准库的一部分。这会带来很大的不同。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1729443|如果考虑用Rust编写操作系统，则不能在代码中使用任何形式的GC，也不能使用标准库。在这个层次上，重要的是要知道什么是语言的一部分，什么不是。对于一个简单的例子，请看一下这里。|1729444|相反，在Java或Python这样的语言中，您不能阻止代码使用GC，因为它通过设计语言隐式地使用它。|1729445|在Rust中，就像在C/C%2B%2B中一样，GC是库的一部分，并且它的使用是显式的。|1729446|entityMap|0|LINK|mutability|MUTABLE|url|https://pcwalton.github.io/blog/2013/06/02/removing-garbage-collection-from-the-rust-language/|1|https://github.com/charliesome/rustboot|2|http://www.hboehm.info/gc/^0|D|1|0|0|2D|2|1|0|0|A|5|2|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@$A|W|B|X|1|Y]]|C|$]]|$1|D|3|E|5|6|7|Z|8|@]|9|@$A|10|B|11|1|12]]|C|$]]|$1|F|3|G|5|6|7|13|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|14|8|@]|9|@$A|15|B|16|1|17]]|C|$]]|$1|J|3|-4|5|6|7|18|8|@]|9|@]|C|$]]]|K|$L|$5|M|N|O|C|$P|Q]]|R|$5|M|N|O|C|$P|S]]|T|$5|M|N|O|C|$P|U]]]]

<a href="https://pcwalton.github.io/blog/2013/06/02/removing-garbage-collection-from-the-rust-language/">This</a> article is a bit old, regarding how Rust has changed now, but it highlights what it means that Rust does not have GC. Only RAII and ownership are intrinsic to Rust. They helps writing reference-counting alike GCs such as Rc and Arc, but those are not part of the language, they're part of the standard library. And it makes a huge difference.

If you consider writing an operating system in Rust, you can't use any form of GC in part of your code or use the standard library. At this level, it's important to know what is part of the language and what is not. For a simple example, have look <a href="https://github.com/charliesome/rustboot">here</a>.

In contrast, in a language such as Java or Python, you can't prevent your code from using the GC as it use it implicitly by design of the language.

In Rust, like in <a href="http://www.hboehm.info/gc/">C/C++</a> a GC is part from a library and it's use is explicit.

<a href="https://doc.rust-lang.org/book/first-edition/README.html" rel="nofollow noreferrer">The Rust Programming Language, first edition</a> says that Rust does not have a garbage collector:

<blockquote>
 It maintains these goals without having a garbage collector
</blockquote>

However, in <a href="https://doc.rust-lang.org/book/first-edition/choosing-your-guarantees.html#rct" rel="nofollow noreferrer">discussing choosing your guarantees</a> it also says:

<blockquote>
 <code>Rc&lt;T&gt;</code> is a reference counted pointer. In other words, this lets us have multiple "owning" pointers to the same data, and the data will be dropped (destructors will be run) when all pointers are out of scope.
</blockquote>

As far as I understand, this is exactly how pointers work in a garbage-collected language like Python.

I consider garbage collection to be any process which prevents the need for manual deallocation of dynamically-allocated memory. I think I don't understand what the Rust guide considers to be garbage collection however.

How are Rust's Arc and Rc types different from having garbage collection?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

说Rust没有垃圾收集器：它维护这些目标，而不需要垃圾收集器。然而，在中，它也说：Rc<T>是一个引用计数指针。换句话说，这允许我们拥有对同一数据的多个“拥有”指针，当所有指针超出作用域时，数据将被删除(析构函数将被运行)。据我所知，这正是指针在像Python这样的垃圾收集语言中的工作方式。我认为垃圾回收是防止手动释放...

问Rust的圆弧和Rc类型与垃圾收集有什么不同？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Rust的圆弧和Rc类型与垃圾收集有什么不同？EN