blocks|key|1623025|text|您永远不应该使用-retainCount，因为它不会告诉您任何有用的信息。Foundation和AppKit/UIKit框架的实现是不透明的；您不知道要保留什么、为什么要保留、谁在保留、何时保留等等。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1623026|例如：|1623027|1623028|您可能认为[NSNumber+numberWithInt:1]的retainCount为1，但事实并非如此。它是2。|unordered-list-item|1623029|您可能认为@"Foo"的retainCount为1。其实不然。It's+|1623030|[NSNumber+numberWithInt:1]的<retainCount>d12为1。其实不然。同样，它是|1623031|1623032|1623033|基本上，由于任何东西都可以保留对象(并因此更改其retainCount)，而且您没有运行应用程序的大多数代码的源代码，因此对象的retainCount是没有意义的。|1623034|如果您试图追踪对象未被释放的原因，请使用Instruments中的Leaks工具。如果你想找出为什么一个对象过早地被释放，可以使用Instruments中的僵尸工具。|1623035|但是不要使用-retainCount。这是一种真正毫无价值的方法。|1623036|编辑|BOLD|1623037|请大家到http://bugreport.apple.com上请求弃用-retainCount。提出要求的人越多越好。|1623038|编辑#2|1623039|作为更新，[NSNumber+numberWithInt:1]现在的retainCount为9223372036854775807。如果你的代码期望它是2，那么你的代码现在已经崩溃了。|1623040|entityMap|0|LINK|mutability|MUTABLE|url|http://bugreport.apple.com/^0|8|C|0|0|0|5|Q|W|B|0|5|6|C|B|0|0|Q|S|B|0|0|0|O|B|1S|B|0|0|6|C|0|0|2|0|Z|C|4|Q|0|0|0|4|0|5|Q|Y|B|0^^$0|@$1|2|3|4|5|6|7|1E|8|@$9|1F|A|1G|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1H|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|1I|8|@]|D|@]|E|$]]|$1|I|3|J|5|K|7|1J|8|@$9|1K|A|1L|B|C]|$9|1M|A|1N|B|C]]|D|@]|E|$]]|$1|L|3|M|5|K|7|1O|8|@$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]]|D|@]|E|$]]|$1|N|3|O|5|K|7|1T|8|@$9|1U|A|1V|B|C]|$9|1W|A|1X|B|C]]|D|@]|E|$]]|$1|P|3|-4|5|K|7|1Y|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|1Z|8|@]|D|@]|E|$]]|$1|R|3|S|5|6|7|20|8|@$9|21|A|22|B|C]|$9|23|A|24|B|C]]|D|@]|E|$]]|$1|T|3|U|5|6|7|25|8|@]|D|@]|E|$]]|$1|V|3|W|5|6|7|26|8|@$9|27|A|28|B|C]]|D|@]|E|$]]|$1|X|3|Y|5|6|7|29|8|@$9|2A|A|2B|B|Z]]|D|@]|E|$]]|$1|10|3|11|5|6|7|2C|8|@$9|2D|A|2E|B|C]]|D|@$9|2F|A|2G|1|2H]]|E|$]]|$1|12|3|13|5|6|7|2I|8|@$9|2J|A|2K|B|Z]]|D|@]|E|$]]|$1|14|3|15|5|6|7|2L|8|@$9|2M|A|2N|B|C]|$9|2O|A|2P|B|C]]|D|@]|E|$]]|$1|16|3|-4|5|6|7|2Q|8|@]|D|@]|E|$]]]|17|$18|$5|19|1A|1B|E|$1C|1D]]]]

You should never use <code>-retainCount</code>, because it never tells you anything useful. The implementation of the Foundation and AppKit/UIKit frameworks is opaque; you don't know what's being retained, why it's being retained, who's retaining it, when it was retained, and so on.

For example:

<ul>
<li>You'd think that <code>[NSNumber numberWithInt:1]</code> would have a <code>retainCount</code> of 1. It doesn't. It's 2.</li>
<li>You'd think that <code>@"Foo"</code> would have a <code>retainCount</code> of 1. It doesn't. It's 1152921504606846975.</li>
<li>You'd think that <code>[NSString stringWithString:@"Foo"]</code> would have a <code>retainCount</code> of 1. It doesn't. Again, it's 1152921504606846975.</li>
</ul>

Basically, since anything can retain an object (and therefore alter its <code>retainCount</code>), and since you don't have the source to most of the code that runs an application, an object's <code>retainCount</code> is meaningless.

If you're trying to track down why an object isn't getting deallocated, use the Leaks tool in Instruments. If you're trying to track down why an object was deallocated too soon, use the Zombies tool in Instruments.

But don't use <code>-retainCount</code>. It's a truly worthless method.

edit

Please everyone go to <a href="http://bugreport.apple.com" rel="noreferrer">http://bugreport.apple.com</a> and request that <code>-retainCount</code> be deprecated. The more people that ask for it, the better.

edit #2

As an update,<code>[NSNumber numberWithInt:1]</code> now has a <code>retainCount</code> of 9223372036854775807. If your code was expecting it to be 2, your code has now broken.

blocks|key|2613284|text|绝不可能!|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2613285|我是认真的。不要这样做。|2613286|只需遵循Memory+Management+Guidelines，只发布您的alloc、new或copy+(或最初调用retain的任何内容)。|offset|length|style|CODE|2613287|@bbum说它最好的是here+on+SO，甚至在his+blog上更详细。|2613288|entityMap|0|LINK|mutability|MUTABLE|url|http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/MemoryMgmt/MemoryMgmt.html|1|https://stackoverflow.com/questions/3730804/how-many-times-do-i-release-an-allocated-or-retained-object/3730835#3730835|2|http://www.friday.com/bbum/2011/12/18/retaincount-is-useless/^0|0|0|12|5|18|3|1C|4|1N|6|4|S|0|0|B|A|1|P|8|2|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Y|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Z|8|@$F|10|G|11|H|I]|$F|12|G|13|H|I]|$F|14|G|15|H|I]|$F|16|G|17|H|I]]|9|@$F|18|G|19|1|1A]]|A|$]]|$1|J|3|K|5|6|7|1B|8|@]|9|@$F|1C|G|1D|1|1E]|$F|1F|G|1G|1|1H]]|A|$]]|$1|L|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]]|M|$N|$5|O|P|Q|A|$R|S]]|T|$5|O|P|Q|A|$R|U]]|V|$5|O|P|Q|A|$R|W]]]]

<h1>NEVER!</h1>
Seriously. Just don't do it.
Just follow the <a href="http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/MemoryMgmt/MemoryMgmt.html" rel="noreferrer">Memory Management Guidelines</a> and only release what you <code>alloc</code>, <code>new</code> or <code>copy</code> (or anything you called <code>retain</code> upon originally).
@bbum said it best <a href="https://stackoverflow.com/questions/3730804/how-many-times-do-i-release-an-allocated-or-retained-object/3730835#3730835">here on SO</a>, and in even more detail on <a href="http://www.friday.com/bbum/2011/12/18/retaincount-is-useless/" rel="noreferrer">his blog</a>.

blocks|key|4215626|text|自动释放的对象是检查-retainCount的一种情况，它没有提供任何信息，并且可能会产生误导。保留计数不会告诉您在一个对象上调用了多少次-autorelease，因此当当前自动释放池耗尽时，它将被释放多少次。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4215627|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Autoreleased objects are one case where checking -retainCount is uninformative and potentially misleading. The retain count tells you nothing about how many times -autorelease has been called on an object and therefore how many time it will be released when the current autorelease pool drains.

blocks|key|4215733|text|I+do发现retainCounts在使用'Instruments‘检查时非常有用。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|4215734|使用‘分配’工具，确保‘记录引用计数’是打开的，你可以进入任何对象并查看其retainCount历史记录。|4215735|通过配对分配和发布，您可以很好地了解正在发生什么，并经常解决某些未发布的困难情况。|4215736|这从来没有让我失望过--包括在iOS的早期测试版中发现错误。|4215737|entityMap^0|2|2|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|R|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|S|8|@]|D|@]|E|$]]|$1|L|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|M|$]]

I do find retainCounts very useful when checked using 'Instruments'.

Using the 'allocations' tool, make sure 'Record reference counts' is turned on and you can go into any object and see its retainCount history.

By pairing allocs and releases you can get a good picture of what is going on and often solve those difficult cases where something is not being released.

This has never let me down - including finding bugs in early beta releases of iOS.

blocks|key|546469|text|看看NSObject上的苹果文档，它几乎涵盖了你的问题：NSObject+retainCount|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|546470|简而言之，除非您实现了自己的引用计数系统(我几乎可以保证您不会实现)，否则retainCount对您可能毫无用处。|546471|用苹果自己的话说，retainCount“在调试内存管理问题方面通常没有价值”。|546472|entityMap|0|LINK|mutability|MUTABLE|url|http://developer.apple.com/library/mac/#documentation/Cocoa/Reference/Foundation/Protocols/NSObject_Protocol/Reference/NSObject.html#//apple_ref/occ/intfm/NSObject/retainCount^0|S|K|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]]]

Take a look at the Apple documentation on NSObject, it pretty much covers your question:
<a href="http://developer.apple.com/library/mac/#documentation/Cocoa/Reference/Foundation/Protocols/NSObject_Protocol/Reference/NSObject.html#//apple_ref/occ/intfm/NSObject/retainCount" rel="nofollow noreferrer">NSObject retainCount</a>

In short, retainCount is probably useless to you unless you've implemented your own reference counting system (and I can almost guarantee you won't have). 

In Apple's own words, retainCount is "typically of no value in debugging memory management issues".

blocks|key|1624680|text|当然，您永远不应该在代码中使用retainCount方法，因为它的值的含义取决于已对对象应用了多少自动释放，而这是您无法预测的。但是，它对于调试非常有用--特别是当您在主事件循环外部调用Appkit对象的方法的代码中寻找内存泄漏时--并且不应该弃用它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1624681|在你努力表明你的观点时，你严重夸大了价值的高深莫测的本质。确实，它并不总是引用计数。有一些特殊的值用于标志，例如，指示对象永远不应该被释放。像1152921504606846975这样的数字看起来非常神秘，直到你用十六进制写成它，并得到0xfffffffffffffffff。9223372036854775807是十六进制的0x7fffffffffffffffffffffffff。假设您每秒递增retainCount+100,000,000次，假设您需要近3000年的时间才能获得与较大数字一样高的retainCount，那么有人选择使用这些值作为标志也就不足为奇了。|1624682|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Of course you should never use the retainCount method in your code, since the meaning of its value depends on how many autoreleases have been applied to the object and that is something you cannot predict. However it is very useful for debugging -- especially when you are hunting down memory leaks in code that calls methods of Appkit objects outside of the main event loop -- and it should not be deprecated.

In your effort to make your point you seriously overstated the inscrutable nature of the value. It is true that it is not always a reference count. There are some special values that are used for flags, for example to indicate that an object should never be deallocated. A number like 1152921504606846975 looks very mysterious until you write it in hex and get 0xfffffffffffffff. And 9223372036854775807 is 0x7fffffffffffffff in hex. And it really is not so surprising that someone would choose to use values like these as flags, given that it would take almost 3000 years to get a retainCount as high as the larger number, assuming you incremented the retainCount 100,000,000 times per second.

blocks|key|2613308|text|使用它会有什么问题？它所做的就是返回对象的保留计数。我从来没有调用过它，也想不出我会调用它的任何原因。我已经在单例中覆盖了它，以确保它们不会被释放。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2613309|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

What problems can you get from using it? All it does is return the retain count of the object. I have never called it and can't think of any reason that I would. I have overridden it in singletons to make sure they aren't deallocated though.

blocks|key|546529|text|在你的应用程序启动并运行并做一些有用的事情之前，你不应该担心内存泄漏。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|546530|一旦发生内存泄漏，启动Instruments并使用应用程序，看看是否真的发生了内存泄漏。在大多数情况下，你自己创建了一个对象(因此你拥有它)，但在完成后忘记了释放它。|546531|不要试图在编写代码时优化代码，当你实际正常使用应用程序时，你对什么可能会泄漏内存或花费太长时间的猜测通常是错误的。|546532|一定要尝试编写正确的代码，例如，如果您使用alloc等工具创建了一个对象，那么请确保您正确地释放了它。|546533|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

You should not be worrying about memory leaking until your app is up and running and doing something useful.

Once it is, fire up Instruments and use the app and see if memory leaks really happen. In most cases you created an object yourself (thus you own it) and forgot to release it after you were done.

Don't try and optimize your code as you are writing it, your guesses as to what may leak memory or take too long are often wrong when you actually use the app normally.

Do try and write correct code e.g. if you create an object using alloc and such, then make sure you release it properly.

blocks|key|546715|text|您永远不应该在代码中使用它，但在调试时它肯定会有所帮助。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|546716|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

You should never use it in your code, but it could definitely help when debugging

blocks|key|4215820|text|永远不要在代码中使用-retainCount。但是，如果您使用，您将永远不会看到它返回零。想一想为什么。:-)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4215821|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Never use the -retainCount in your code. However if you use, you will never see it returns zero. Think about why. :-)

blocks|key|1624702|text|戴夫的帖子中使用的例子是NSNumber和NSStrings...so，如果你使用其他一些类，比如UIViews，我相信你会得到正确的答案(保留计数取决于实现，它是可预测的)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1624703|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The examples used in Dave's post are NSNumber and NSStrings...so, if you use some other classes, such as UIViews, I'm sure you will get the correct answer(The retain count depends on the implementation, and it's predictable).

I would like to know in what situation did you use <code>-retainCount</code> so far, and eventually the problems that can happen using it.

Thanks.

When to use -retainCount?

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

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

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

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

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

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

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

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

我想知道你到目前为止在什么情况下使用-retainCount，以及最终使用它可能会发生的问题。谢谢。

问什么时候使用-retainCount？
EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么时候使用-retainCount？EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么时候使用-retainCount？
EN