1、[NSObject alloc]在创建完对象后，会让该对象的retainCount+1，后续的init为初始化该对象属性的函数。
若alloc成功后，不把该地址引用赋值给某个指针变量NSObject *obj，则该新创建的对象的引用计数始终为1。
则整个程序运行的声明周期内，该内存都不会被回收，malloc、new也是同样的道理，所以会引起内存泄露。
2、ARC下虽然不能直接调用retainCount查看引用计数，但也可以通过以下几种方式work round。
方法一：[obj valueForKey:@"retainCount"];
这个方法测了一下经常不准，但好处是在引用计数==0，obj被回收以后不会报错，另外两种会报错。
方法二：OBJC_EXTERN int _objc_rootRetainCount(id);
_objc_rootRetainCount(obj);
方法三：CFGetRetainCount((__bridge CFTypeRef)obj);
============================================
关于autoreleasepool
自动释放池是NSAutoreleasePool的实例，其中包含了收到autorelease消息的对象。当一个自动释放池自身被销毁（dealloc）时，它会给池中每一个对象发送一个release消息。
如果你给一个对象多次发送autorelease消息，那么当自动释放池销毁时，这个对象也会收到同样数目的release消息。
需要注意的是：如果在delloc里面没有调用[super delloc]，这样做没有问题，只是delloc被多次调用。但如果有[super delloc]，则第二次重复调用会产生exc_bad_access或者signal sigabrt。所以还是不要在一个autoreleasepool里对同一个对象做一次以上的autorelease函数调用，何况这么做没有任何意义。
可以看出，一个自动释放的对象，它至少能够存活到自动释放池销毁的时候。这样看来它是一种延迟释放机制，这样保证局部堆上的变量能够被外部正常使用。
以下写法也是一样生效的：
NSObject *obj = [NSObject new];
@autoreleasepool{
[obj autorelease];
// 1. [obj release];
// 2. [obj retain];
}
// 到这里的时候obj就被释放了
可见并不是必须在alloc的时候调用autorelease，也不是必须在@autoreleasepool内部调用alloc创建对象，总之只要是在@autoreleasepool内部调用过autorelease的对象，都会在@autoreleasepool作用域结束的时候调用release，仅此而已。
如果在注释1的位置直接调用release，那么obj会因为retainCount==0立刻被回收，而不会等到autoreleasepool作用域结束，虽然在那是又执行一遍release，但是没有意义了。
如果在注释2的位置再次调用retain，那么就是到autoreleasepool作用域结束调用一次release，那么因为retainCount==1, obj对象引用的内存还是不会回收，要么在调用一次release，要么再调用一次autorelease。
也就是说，alloc/new/copy/retain是一组增加retainCount的，release和autoRelease是一组减少retainCount的，要释放内存第一组和第二组的调用次数要完全一致。
小结：
只有在自动释放池中调用了对象的autorelease方法,这个对象才会被存储到这个自动释放池之中.
如果只是将对象的创建代码写在自动释放之中,而没有调用对象的autorelease方法.是不会将这个对象存储到这个自动释放池之中的.
对象的创建可以在自动释放池的外面,在自动释放池之中,调用对象的autorelease方法,就可以将这个对象存储到这个自动释放池之中.如果对象的autorelease方法的调用放在自动释放池的外面,是无法将其存储的这个自动释放池之中的.
autorelease 的调用只有放在自动释放池之中 才可以讲其存储到自动释放池之中, 对象的创建可以在外面
当自动释放池结束的时候.仅仅是对存储在自动释放池中的对象发送1条release消息 而不是销毁对象.
如果在自动释放池中,调用同1个对象的autorelease方法多次.就会将对象存储多次到自动释放池之中.
在自动释放池结束的时候.会为对象发送多条release消息.
所以,1个自动释放池之中,只autorelease1次,只将这个对象放1次, 否则就会出现野指针错误.如果在自动释放池中,调用了存储到自动释放中的对象的release方法.
在自动释放池结束的时候,还会再调用对象的release方法.
这个时候就有有可能会造成野指针操作.将对象存储到自动释放池,并不会使对象的引用计数器+1 所以其好处就是:创建对象将对象存储在自动释放池,就不需要在写个release了.
自动释放池可以嵌套.
调用对象的autorelease方法,会讲对象加入到当前自动释放池之中
只有在当前自动释放池结束的时候才会像对象发送release消息.
============================================
在创建对象的时候，调用autorelease，就能将该对象放到autoreleasepool中。利用autoreleasepool的延迟释放来管理内存。autoreleasepool这么重要，可是我们在实际开发中并没有手动创建autoreleasepool，却没有内存泄露。这是为什么呢？其实没有手动创建并不代表它不会被创建，那么它是什么时候创建的呢？
iOS程序默认在main函数中会加入@autoreleasepool，但这个基本没什么用，因为它的作用域是整个main函数结束，也就是说延迟release的时间点是程序退出之前，那么既然程序都退出了，所有资源和内存都已经被操作系统回收了，还释放个什么劲啊？
所以实际上iOS程序在运行过程中，远不止我们自己实现的代码里会添加@autoreleasepool，autoreleasepool的数据存储结构是一个嵌套结构，也就是说可以在一个autoreleasepool内部嵌套另一个autoreleasepool并且可以无限嵌套下去。这有点类似函数的栈变量压栈和出栈的逻辑。所以runtime自动调用和创建的autoreleasepool对程序开发者来说基本是透明的。
App启动后，系统在主线程runLoop里注册两个Observser,其回调都是_wrapRunLoopWithAutoreleasePoolHandler()。第一个 Observer 监视的事件是 Entry(即将进入Loop)，其回调内会调用 _objc_autoreleasePoolPush() 创建自动释放池。其优先级最高，保证创建释放池发生在其他所有回调之前。第二个 Observer 监视了两个事件： BeforeWaiting(准备进入休眠) 时调用_objc_autoreleasePoolPop() 和 _objc_autoreleasePoolPush() 释放旧的池并创建新池；Exit(即将退出Loop) 时调用 _objc_autoreleasePoolPop() 来释放自动释放池。这个 Observer 优先级最低，保证其释放池子发生在其他所有回调之后。在主线程执行的代码，通常是写在诸如事件回调、Timer回调内的。这些回调会被runLoop创建好的AutoreleasePool环绕着。这就解释了，为什么即使程序中只有main函数的最外层设置autoreleasepool，所有的内存也不是在main运行完后一股脑一起释放的原因，可以说最外层的autoreleasepool只是为了保护所有没有被内建的autoreleasepool包裹住的部分内存自动回收用的。
通过下面的例子，我们来看一下，runLoop创建的autoreleasepool是不是真的帮我们管理了内存。
__weak id reference = nil;
- (void)viewDidLoad {
[super viewDidLoad];
NSString *str = [NSString stringWithFormat:@"autoreleasePool"];
// str是一个autorelease对象，设置一个weak的引用来观察它
reference = str;
NSLog(@"%@", reference); // Console: autoreleasePool
}
- (void)viewWillAppear:(BOOL)animated {
[super viewWillAppear:animated];
NSLog(@"%@", reference); // Console: autoreleasePool
}
- (void)viewDidAppear:(BOOL)animated {
[super viewDidAppear:animated];
NSLog(@"%@", reference); // Console: (null)
}
这个实验同时也证明了viewDidLoad和viewWillAppear是在同一个runloop调用的，而viewDidAppear是在之后的某个runloop调用的。由于这个vc在loadView之后便add到了window层级上，所以viewDidLoad和viewWillAppear是在同一个runloop调用的，因此在viewWillAppear中，这个autorelease的变量依然有值。
当然，我们也可以不用等到当前runLoop结束，选择手动干预Autorelease对象的释放时机：
- (void)viewDidLoad {
[super viewDidLoad];
@autoreleasepool {
NSString *str = [NSString stringWithFormat:@"autoreleasePool"];
}
NSLog(@"%@", str); // Console: (null)
}
通过上面的例子，可以看出，没有调用release也做到了内存管理。可是大家注意到了，str对象没有调用autorelease方法啊，怎么被放到autoreleasepool进行管理的呢？其实静态方法已经在内部自动调用了autorelease方法，所有这里不需要再调用。
更进一步讲，ARC在进行内存释放管理的时候，如果某个对象是在独立作用域中创建并且使用，没有外层作用域对它的引用的话(没有外层作用域指针指向，也没有从函数返回值中返回)，则很可能编译的时候使用release立刻释放。但若不是这样，则一定使用autorelease来减少复杂度，比如上面的stringWithFormat静态方法，就是在其函数内执行了[NSString alloc]，但其创建对象的引用作为返回值进行了返回，所以必然会添加autorelease，因为如果是使用release的话，由于编译器必须在return函数前面来调用release函数，而调用release函数后引用计数==0立刻释放了该对象，则无论如何都会返回一个已经被释放的野指针作为函数返回值，唯一的办法就只能是把release延迟调用，来起码等到调用者拿到对象的引用并决定是weak还是strong之后再延迟释放。
=========================================
继续我们的主题。我们知道autoreleasepool是一个自动释放池，那么它到底是一个什么样的数据结构呢？我们在命令行中使用 clang -rewrite-objc main.m 让编译器重新改写这个文件，编译完后，会在该文件目录下多一个.cpp文件。打开这个文件。滚到最底部。可以看到如下代码：（删除掉多余的代码）
很遗憾的是这里只能看到autoreleasepool被编译的部分，如果还有NSObject *obj = [[NSObject alloc] init];这种定义，是看不到编译器自动在最后加上的[obj release]调用的，可能是这部分属于llvm的特性，用clang的重写是看不到的。
int main(int argc, const charchar * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
}
return 0;
}
在这个文件中，有一个非常奇怪的 __AtAutoreleasePool 的结构体，前面的注释写到/* @autoreleasepopl */ 。也就是说@autoreleasepool {} 被转换为：__AtAutoreleasePool __autoreleasepool。那么__AtAutoreleasePool又是什么？在文件中可以找到__AtAutoreleasePool数据结构如下：
struct __AtAutoreleasePool {
__AtAutoreleasePool() {atautoreleasepoolobj = objc_autoreleasePoolPush();}
~__AtAutoreleasePool() {objc_autoreleasePoolPop(atautoreleasepoolobj);}
voidvoid * atautoreleasepoolobj;
};
它是一个结构体，该结构体会在初始化时调用 objc_autoreleasePoolPush() 方法，会在析构时调用objc_autoreleasePoolPop 方法。所以我们可以进一步将main函数中的代码改写为如下：
int main(int argc, const charchar * argv[]) {
{
voidvoid * atautoreleasepoolobj = objc_autoreleasePoolPush();
// do whatever you want
objc_autoreleasePoolPop(atautoreleasepoolobj);
}
return 0;
}
@autoreleasepool 只是帮助我们少写了这两行代码而已，让代码看起来更美观，然后要根据上述两个方法来分析自动释放池的实现。objc_autoreleasePoolPush 和 objc_autoreleasePoolPop 的实现：
voidvoid *objc_autoreleasePoolPush(void) {
return AutoreleasePoolPage::push();
}
void objc_autoreleasePoolPop(voidvoid *ctxt) {
AutoreleasePoolPage::pop(ctxt);
}
__AtAutoreleasePool的Push和Pop方法看上去方法看上去是对 AutoreleasePoolPage对应静态方法push和pop的封装。
那么AutoreleasePoolPage又是一个什么东东呢？，它的定义可以在NSObject.mm文件中看到，定义如下：
class AutoreleasePoolPage {
magic_t const magic;
idid *next;
pthread_t const thread;
AutoreleasePoolPage * const parent;
AutoreleasePoolPage *child;
uint32_t const depth;
uint32_t hiwat;
};
=========================================
以上的过程说明了autoreleasepool可以由系统调用自动多次嵌套，而且只对调用了autorelease的对象起作用。
ARC是在编译阶段由LLVM自动加入reatin，release，autorelease等操作函数，那么对于栈作用域的函数内部变量来说，会在函数退出之前对局部变量引用的对象执行release操作，当retainCount==0的时候立刻执行回收内存操作。而@autoreleasepool可以让这个操作提前，例如：
- (void) doSomething {
__weak NSMutableArray *wcollection;
@autoreleasepool{
NSMutableArray *collection = @[].mutableCopy;
wcollection = collection;
for (int i = 0; i < 10e6; ++i) {
NSString *str = [NSString stringWithFormat:@"hi + %d", i];
[collection addObject:str];
}
NSLog(@"%d",_objc_rootRetainCount(collection)); //打印1
NSLog(@"finished!");
}
NSLog(@"%d",[wcollection valueForKey:@"retainCount"]); //打印0
// 其他的代码
NSLog(@"completed!");
}
以上的例子中，如果不使用局部的@autoreleasepool（但是还是要保留{}以减小collection的作用域），则collection引用的对象虽然在{}作用域的最后会被release，并且将其中add过的str对象都做release操作，但由于str在通过静态方法创建的时候进行了一次持有并且用autorelease释放，所以str还占用的内存要在autoreleasepool drain的时候才能释放。另外还能确定在超过函数作用域的对象多次引用(比如doSomething中return collection)，或者多线程并发引用同一个外部对象的情况下，想通过添加release第一时间释放的难度太大，所以ARC会选择使用autorelease，在更外层更好控制的地方使用autoreleasepool进行延迟释放。
而如果在collection使用的外部套上@autoreleasepool，则执行完成后会立刻释放str所占用的内存，也就是说会降低整个函数执行过程中，内存占用的峰值。另外大量的释放内存也会占用不少cpu时间，所以在打印完finished!以后，到//其他代码执行之前，会卡住一段时间，从执行监视器视图看，这段时间内程序占用的内存会持续下降。
for(int i=0;i<10e6;i++){
[[NSString alloc] initWithFormat:@"hi:%d",i];
__weak NSString *str = [[NSString alloc] initWithFormat:@"hi:%d",i];
NSLog(@"%@",str); // 打印nil
NSString *str2 = [[NSString alloc] initWithFormat:@"hi:%d",i];
NSLog(@"%@",str2);// 打印字符串
}
ARC的情况下，第一种写法编译器会立刻优化为[[[NSString alloc] initWithFormat:@"hi:%d",i] release]，所以虽然cpu在不断的执行和创建销毁对象，但内存不变化。
第二种写法用弱引用接收跟不接收一下不能增加引用计数，则同理。打印为nil
第三种写法有区别，可以打印出字符串，编译器会在{}作用域的最后一行加上[str2 release]，而不是alloc之后立刻回收。
可以想象为一个虚拟的强引用指针
NSString *temp = [alloc init];
第一种写法什么都不做
第二种写法_weak NSString *str = temp;
第三种写法NSString *str2 = temp;
[temp release];
// alloc之后的代码
MRC的情况下就比较悲剧了,__weak在MRC下不可用编译不通过，另外两种写法都会因为没有release让内存持续增长，尤其是第一种写法，想release都没有办法。
=========================================
__autoreleasing修饰符的作用
切换到ARC之后，每个指向OC对象的指针，都被赋上了所有权修饰符。一共有__strong、__weak、__unsafe_unretained和__autoreleasing这样四种所有权修饰符。
当一个对象被赋值给一个使用__autoreleasing修饰符修饰的指针时，相当于这个对象在MRC下被发送了autorelease消息，也就是说它被注册到了autorelease pool中。
全局变量和实例变量是无法用__autoreleasing来修饰的，不然编译器会报错。
而局部变量用__autoreleasing修饰后，其指向的对象，在当前autorelease pool结束之前不会被回收，即使其生命的作用域结束。也就是说__autoreleasing让编译器改变了默认的处理原则。
__weak NSObject *weakObj1;
__weak NSObject *weakObj2;
{
__autoreleasing NSObject *obj1 = [[NSObject alloc] init];
weakObj1 = obj1; //weakObj1指向的对象已被注册到autorelease pool
__strong NSObject *obj2 = [[NSObject alloc] init];
weakObj2 = obj2;//weakObj2指向的对象没有被注册到autorelease pool
}
//局部变量obj1和obj2的作用域结束，
//此时weakObj2指向的对象不再被强引用，因此被回收；
//而obj1指向的对象仍然在autorelease pool中
NSLog(@"%@", weakObj1);//输出<NSObject: 0x100206030>，因为此刻weakObj1在autorelease pool中，不会因为obj1作用域的结束而被回收
NSLog(@"%@", weakObj2);//输出null
=========================================
方法名检查
@interface XSQObject : NSObject
+ (NSString *)newHelloWorldString;
+ (NSString *)allocHelloWorldString;
+ (NSString *)copyHelloWorldString;
+ (NSString *)helloWorldString;
+ (NSString *)initHelloWorldString;
+ (NSString *)shitHelloWorldString;
@end
@implementation XSQObject
+ (NSString *)newHelloWorldString {
return [[NSString alloc] initWithCString:"HelloWorld" encoding:NSUTF8StringEncoding];
}
+ (NSString *)allocHelloWorldString {
return [[NSString alloc] initWithCString:"HelloWorld" encoding:NSUTF8StringEncoding];
}
+ (NSString *)copyHelloWorldString {
return [[NSString alloc] initWithCString:"HelloWorld" encoding:NSUTF8StringEncoding];
}
+ (NSString *)helloWorldString {
return [[NSString alloc] initWithCString:"HelloWorld" encoding:NSUTF8StringEncoding];
}
+ (NSString *)initHelloWorldString {
return [[NSString alloc] initWithCString:"HelloWorld" encoding:NSUTF8StringEncoding];
}
+ (NSString *)shitHelloWorldString {
return [[NSString alloc] initWithCString:"HelloWorld" encoding:NSUTF8StringEncoding];
}
@end
int main(int argc, char * argv[]) {
@autoreleasepool {
__weak NSString *newHelloWorldString = [XSQObject newHelloWorldString];
__weak NSString *allocHelloWorldString = [XSQObject allocHelloWorldString];
__weak NSString *copyHelloWorldString = [XSQObject copyHelloWorldString];
//上面三个都有warning:
//Assigning retained object to weak variable; object will be released after assignment
NSLog(@"%@", newHelloWorldString);//输出null
NSLog(@"%@", allocHelloWorldString);//输出null
NSLog(@"%@", copyHelloWorldString);//输出null
__weak NSString *helloWorldString = [XSQObject helloWorldString];
__weak NSString *initHelloWorldString = [XSQObject initHelloWorldString];
__weak NSString *shitHelloWorldString = [XSQObject shitHelloWorldString];
//上面三个没有warning
NSLog(@"%@", helloWorldString);//输出HelloWorld
NSLog(@"%@", initHelloWorldString);//输出HelloWorld
NSLog(@"%@", shitHelloWorldString);//输出HelloWorld
}
return 0;
}
虽然[XSQObject helloWorldString]和[XSQObject newHelloWorldString]两个方法的实现完全一样，但是它们返回的对象被赋值给__weak指针后，前者仍然存在，而后者则被销毁了。如果再加入@autorelease块做点实验，可以发现helloWorldString指向的对象其实已被注册到autorelease pool中。
对比内存管理原则，这就像是在MRC下，不以alloc/new/copy/mutableCopy开头的方法，会对返回的对象发送autorelease消息一样。而事实上，在ARC下，编译器会检查方法名是否以alloc/new/copy/mutableCopy开头，如果不是，则自动将返回的对象注册到autorelease pool中。
在一些特殊的情况下，程序员也可以手动给某些方法加上其他标记，来覆盖被编译器隐式加上的标记。
需要注意的一点是，clang的ARC文档描述如下：
Methods in the alloc, copy, init, mutableCopy, and new families are implicitly marked attribute((ns_returns_retained)). This may be suppressed by explicitly marking the method attribute((ns_returns_not_retained)).
但其实还有一个更详细的默认规则限定，那就是init用作实例方法的开头，其他的用作静态方法的开头。这就是为什么上面的例子中用init开头的静态方法却没有警告和预期结果的原因。
=========================================
更详细的内容可以参考
http://blog.csdn.net/shxwork/article/details/51437003
http://blog.csdn.net/shxwork/article/details/51363306
http://www.jianshu.com/p/1b66c4d47cd7 （强烈推荐）
http://www.jianshu.com/p/32265cbb2a26（强烈推荐）
http://www.jianshu.com/p/ec2c854b2efd
