内存管理

CADisplayLink、NSTimer使用注意

@property (strong, nonatomic) CADisplayLink *link;
@property (strong, nonatomic) NSTimer *timer;

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    // 保证调用频率和屏幕的刷帧频率一致，60FPS
    self.link = [CADisplayLink displayLinkWithTarget:self selector:@selector(linkTest)];
    [self.link addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSDefaultRunLoopMode];
    
    self.timer = [NSTimer scheduledTimerWithTimeInterval:1.0 target:self  selector:@selector(timerTest) userInfo:nil repeats:YES];
}

- (void)timerTest
{
    NSLog(@"%s", __func__);
}

- (void)linkTest
{
    NSLog(@"%s", __func__);
}

- (void)dealloc
{
    NSLog(@"%s", __func__);
    [self.link invalidate];
    [self.timer invalidate];
}

CADisplayLink、NSTimer会对target产生强引用，如果target又对它们产生强引用，那么就会引发循环引用, dealloc方法并不会走

解决方案：
Timer用block方案

__weak typeof(self) weakSelf = self;
self.timer = [NSTimer scheduledTimerWithTimeInterval:1.0 repeats:YES block:^(NSTimer * _Nonnull timer) {
      [weakSelf timerTest];
}];

timer对block强引用，block对self弱引用

使用代理对象（NSProxy）

self.timer = [NSTimer scheduledTimerWithTimeInterval:1.0 target:[NJFProxy proxyWithTarget:self] selector:@selector(timerTest) userInfo:nil repeats:YES];

@interface NJFProxy : NSProxy
+ (instancetype)proxyWithTarget:(id)target;
@property (weak, nonatomic) id target;
@end

@implementation NJFProxy

+ (instancetype)proxyWithTarget:(id)target
{
    // NSProxy对象不需要调用init，因为它本来就没有init方法
    NJFProxy *proxy = [NJFProxy alloc];
    proxy.target = target;
    return proxy;
}

- (NSMethodSignature *)methodSignatureForSelector:(SEL)sel
{
    return [self.target methodSignatureForSelector:sel];
}

- (void)forwardInvocation:(NSInvocation *)invocation
{
    [invocation invokeWithTarget:self.target];
}
@end

GCD定时器

NSTimer依赖于RunLoop，如果RunLoop的任务过于繁重，可能会导致NSTimer不准时
GCD定时器不受RunLoop约束

@interface NJFTimer : NSObject

+ (NSString *)execTask:(void(^)(void))task
           start:(NSTimeInterval)start
        interval:(NSTimeInterval)interval
         repeats:(BOOL)repeats
           async:(BOOL)async;

+ (NSString *)execTask:(id)target
              selector:(SEL)selector
                 start:(NSTimeInterval)start
              interval:(NSTimeInterval)interval
               repeats:(BOOL)repeats
                 async:(BOOL)async;

+ (void)cancelTask:(NSString *)name;

@end

@implementation NJFTimer

static NSMutableDictionary *timers_;
dispatch_semaphore_t semaphore_;

+ (void)initialize
{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        timers_ = [NSMutableDictionary dictionary];
        semaphore_ = dispatch_semaphore_create(1);
    });
}

+ (NSString *)execTask:(void (^)(void))task start:(NSTimeInterval)start interval:(NSTimeInterval)interval repeats:(BOOL)repeats async:(BOOL)async
{
    if (!task || start < 0 || (interval <= 0 && repeats)) return nil;
    // 队列
    dispatch_queue_t queue = async ? dispatch_get_global_queue(0, 0) : dispatch_get_main_queue();
    // 创建定时器
    dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
    // 设置时间
    dispatch_source_set_timer(timer,
                              dispatch_time(DISPATCH_TIME_NOW, start * NSEC_PER_SEC),
                              interval * NSEC_PER_SEC, 0);
    dispatch_semaphore_wait(semaphore_, DISPATCH_TIME_FOREVER);
    // 定时器的唯一标识
    NSString *name = [NSString stringWithFormat:@"%zd", timers_.count];
    // 存放到字典中
    timers_[name] = timer;
    dispatch_semaphore_signal(semaphore_);
    // 设置回调
    dispatch_source_set_event_handler(timer, ^{
        task();
        if (!repeats) { // 不重复的任务
            [self cancelTask:name];
        }
    });
    // 启动定时器
    dispatch_resume(timer);
    return name;
}

+ (NSString *)execTask:(id)target selector:(SEL)selector start:(NSTimeInterval)start interval:(NSTimeInterval)interval repeats:(BOOL)repeats async:(BOOL)async
{
    if (!target || !selector) return nil;
    return [self execTask:^{
        if ([target respondsToSelector:selector]) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
            [target performSelector:selector];
#pragma clang diagnostic pop
        }
    } start:start interval:interval repeats:repeats async:async];
}

+ (void)cancelTask:(NSString *)name
{
    if (name.length == 0) return;
    
    dispatch_semaphore_wait(semaphore_, DISPATCH_TIME_FOREVER);
    dispatch_source_t timer = timers_[name];
    if (timer) {
        dispatch_source_cancel(timer);
        [timers_ removeObjectForKey:name];
    }
    dispatch_semaphore_signal(semaphore_);
}

@end

iOS程序的内存布局

  • 代码段：编译之后的代码

  • 数据段
    字符串常量：比如NSString *str = @"123"
    已初始化数据：已初始化的全局变量、静态变量等
    未初始化数据：未初始化的全局变量、静态变量等

  • 栈：函数调用开销，比如局部变量,分配的内存空间地址越来越小

  • 堆：通过alloc、malloc、calloc等动态分配的空间，分配的内存空间地址越来越大

Tagged Pointer

  • 从64bit开始，iOS引入了Tagged Pointer技术，用于优化NSNumber、NSDate、NSString等小对象的存储

  • 在没有使用Tagged Pointer之前， NSNumber等对象需要动态分配内存、维护引用计数等，NSNumber指针存储的是堆中NSNumber对象的地址值

  • 使用Tagged Pointer之后，NSNumber指针里面存储的数据变成了：Tag + Data，也就是将数据直接存储在了指针中

  • 当指针不够存储数据时，才会使用动态分配内存的方式来存储数据

  • objc_msgSend能识别Tagged Pointer，比如NSNumber的intValue方法，直接从指针提取数据，节省了以前的调用开销

如何判断一个指针是否为Tagged Pointer？

static inline bool 
_objc_isTaggedPointer(const void * _Nullable ptr)
{
    return ((uintptr_t)ptr & _OBJC_TAG_MASK) == _OBJC_TAG_MASK;
}

#if (TARGET_OS_OSX || TARGET_OS_IOSMAC) && __x86_64__
    // 64-bit Mac - tag bit is LSB
#   define OBJC_MSB_TAGGED_POINTERS 0
#else
    // Everything else - tag bit is MSB
#   define OBJC_MSB_TAGGED_POINTERS 1
#endif

#if OBJC_MSB_TAGGED_POINTERS
如果是iOS平台, 最高有效位是1（第64bit, 使用高位优先规则 MSB)
#   define _OBJC_TAG_MASK (1UL<<63)
#else
如果是mac平台, 最低有效位是1(低位优先规则 LSB)
#   define _OBJC_TAG_MASK 1UL
#endif

面试题

思考以下2段代码能发生什么事？有什么区别？

dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
   for (int i = 0; i < 1000; i++) {
       dispatch_async(queue, ^{
           // 加锁
           self.name = [NSString stringWithFormat:@"abcdefghijk"];
           // 解锁
       });
}
    
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    for (int i = 0; i < 1000; i++) {
       dispatch_async(queue, ^{
           self.name = [NSString stringWithFormat:@"abc"];
      });
 }

先看如下代码执行结果(ios项目)

NSString *str1 = [NSString stringWithFormat:@"abcdefghijk"];
NSString *str2 = [NSString stringWithFormat:@"abc"];
NSLog(@"%@ %@", [str1 class], [str2 class]);
NSLog(@"%p %p", str1,str2);

__NSCFString NSTaggedPointerString
0x28129d540 0xf5ad71b08c1d52a1

str1内存地址很明显不够64位，高位补0 & 1 = 0，最高位不是1，所以不是Tagged Pointer，是OC对象
str2内存地址从右往左，第16位是f, 换算成二进制就是0b1111,最高位1 & 1 = 1，所以是Tagged Pointer，不是OC对象

self.name会调用如下代码，由于是异步全局并发队列，所以会有多条线程执行release操作，会造成EXC_BAD_ACCESS，坏内存访问

- (void)setName:(NSString *)name
{
    if (_name != name) {
        [_name release];
        _name = [name retain];
    }
}

OC对象的内存管理

  • 在iOS中，使用引用计数来管理OC对象的内存

  • 一个新创建的OC对象引用计数默认是1，当引用计数减为0，OC对象就会销毁，释放其占用的内存空间

  • 调用retain会让OC对象的引用计数+1，调用release会让OC对象的引用计数-1

  • 内存管理的经验总结
    当调用alloc、new、copy、mutableCopy方法返回了一个对象，在不需要这个对象时，要调用release或者autorelease来释放它
    想拥有某个对象，就让它的引用计数+1；不想再拥有某个对象，就让它的引用计数-1

  • 可以通过以下私有函数来查看自动释放池的情况

extern void _objc_autoreleasePoolPrint(void);

copy和mutableCopy

1、浅拷贝
浅拷贝就是对内存地址的复制，让目标对象指针和源对象指向同一片内存空间，当内存销毁的时候，指向这片内存的几个指针需要重新定义才可以使用，要不然会成为野指针。

image

浅拷贝就是拷贝指向原来对象的指针，使原对象的引用计数+1，可以理解为创建了一个指向原对象的新指针而已，并没有创建一个全新的对象
2、深拷贝
深拷贝是指拷贝对象的具体内容，而内存地址是自主分配的，拷贝结束之后，两个对象虽然存的值是相同的，但是内存地址不一样，两个对象也互不影响，互不干涉。

image

深拷贝就是拷贝出和原来仅仅是值一样，但是内存地址完全不一样的新的对象，创建后和原对象没有任何关系

深拷贝就是内容拷贝，浅拷贝就是指针拷贝

No1：可变对象的copy和mutableCopy方法都是深拷贝（区别完全深拷贝与单层深拷贝）
No2：不可变对象的copy方法是浅拷贝，mutableCopy方法是深拷贝。
No3：copy方法返回的对象都是不可变对象。

引用计数的存储

在64bit中，引用计数可以直接存储在优化过的isa指针中，也可能存储在SideTable类中

inline uintptr_t 
objc_object::rootRetainCount()
{
    if (isTaggedPointer()) return (uintptr_t)this;
    sidetable_lock();
    isa_t bits = LoadExclusive(&isa.bits);
    ClearExclusive(&isa.bits);
    if (bits.nonpointer) {//优化过的isa
        uintptr_t rc = 1 + bits.extra_rc;
        if (bits.has_sidetable_rc) {//引用计数不是储存在isa中，而是储存在sidetable中
            rc += sidetable_getExtraRC_nolock();
        }
        sidetable_unlock();
        return rc;
    }
    sidetable_unlock();
    return sidetable_retainCount();
}


struct SideTable {
    spinlock_t slock;
*******************************
refcnts是一个存放着对象引用计数的散列表
*******************************
    RefcountMap refcnts;
*************************************
弱引用表，当前对象的内存地址作为key，指向该对象的弱引用指针作为value
*************************************
    weak_table_t weak_table;
....
};

dealloc

当一个对象要释放时，会自动调用dealloc

- (void)dealloc {
    _objc_rootDealloc(self);
}

inline void
objc_object::rootDealloc()
{
    if (isTaggedPointer()) return;  // fixme necessary?
    if (fastpath(isa.nonpointer  &&  
                 !isa.weakly_referenced  &&  
                 !isa.has_assoc  &&  
                 !isa.has_cxx_dtor  &&  
                 !isa.has_sidetable_rc))
    {
        assert(!sidetable_present());
        free(this);
    } 
    else {
        object_dispose((id)this);
    }
}

id 
object_dispose(id obj)
{
    if (!obj) return nil;
    objc_destructInstance(obj);    
    free(obj);
    return nil;
}

void *objc_destructInstance(id obj) 
{
    if (obj) {
        // Read all of the flags at once for performance.
        bool cxx = obj->hasCxxDtor();
        bool assoc = obj->hasAssociatedObjects();
        // This order is important.
        if (cxx) object_cxxDestruct(obj);//清除成员变量
        if (assoc) _object_remove_assocations(obj);//清除关联对象
*************************************
将指向当前的对象的弱指针置为nil
*************************************
        obj->clearDeallocating();
    }
    return obj;
}

inline void 
objc_object::clearDeallocating()
{
    if (slowpath(!isa.nonpointer)) {
        // Slow path for raw pointer isa.
        sidetable_clearDeallocating();
    }
    else if (slowpath(isa.weakly_referenced  ||  isa.has_sidetable_rc)) {
        // Slow path for non-pointer isa with weak refs and/or side table data.
        clearDeallocating_slow();
    }
    assert(!sidetable_present());
}
......

自动释放池

自动释放池的主要底层数据结构是：__AtAutoreleasePool、AutoreleasePoolPage
调用了autorelease的对象最终都是通过AutoreleasePoolPage对象来管理的
源码分析

@autoreleasepool { }

转为C++底层源码

__AtAutoreleasePool __autoreleasepool

声明了一个__AtAutoreleasePool类型的局部变量

struct __AtAutoreleasePool {
  __AtAutoreleasePool() {//构造函数，在创建结构体的时候调用
atautoreleasepoolobj = objc_autoreleasePoolPush();
}
  ~__AtAutoreleasePool() {//// 析构函数，在结构体销毁的时候调用
objc_autoreleasePoolPop(atautoreleasepoolobj);
}
  void * atautoreleasepoolobj;
};

源码https://opensource.apple.com/tarballs/objc4/

void *
objc_autoreleasePoolPush(void)
{
    return AutoreleasePoolPage::push();
}

void
objc_autoreleasePoolPop(void *ctxt)
{
    AutoreleasePoolPage::pop(ctxt);
}

static inline void *push() 
{
     id *dest;
    //判断是否是debug 环境
     if (slowpath(DebugPoolAllocation)) {
          // Each autorelease pool starts on a new pool page.
          dest = autoreleaseNewPage(POOL_BOUNDARY);
      } else {
          dest = autoreleaseFast(POOL_BOUNDARY);
      }
      ASSERT(dest == EMPTY_POOL_PLACEHOLDER || *dest == POOL_BOUNDARY);
      return dest;
}

AutoreleasePoolPage的结构

class AutoreleasePoolPage : private AutoreleasePoolPageData{
}

struct AutoreleasePoolPageData
{
    magic_t const magic;     16      检查结构体完整性
    __unsafe_unretained id *next;    8 next指针，指向最新添加的 autoreleased 对象的下个位置
    pthread_t const thread;   8  指向当前线程  用来取出自动释放池
    AutoreleasePoolPage * const parent;   8 指向父结点，第一个结点的 parent 值为nil
    AutoreleasePoolPage *child;    8  指向子结点，最后一个结点的 child 值为nil
    uint32_t const depth;  4  深度 链表链层的深度 从0开始，往后递增1
    uint32_t hiwat;   4 最大入栈数量
.....
};   56个字节
  • 每个AutoreleasePoolPage对象占用4096字节内存，除了用来存放它内部的成员变量，剩下的空间用来存放autorelease对象的地址
  • 所有的AutoreleasePoolPage对象通过双向链表的形式连接在一起
  • 调用push方法会将一个POOL_BOUNDARY入栈，并且返回其存放的内存地址
  • 调用pop方法时传入一个POOL_BOUNDARY的内存地址，会从最后一个入栈的对象开始发送release消息，直到遇到这个POOL_BOUNDARY

POOL_BOUNDARY 边界（哨兵对象），每创建一个@autoreleasepool { } 就会创建一个POOL_BOUNDARY

示例

extern void _objc_autoreleasePoolPrint(void);

int main(int argc, const char * argv[]) {
    @autoreleasepool { //  r1 = push()
        NSObject *obj1 = [[[NSObject alloc] init] autorelease];
        NSObject *obj2 = [[[NSObject alloc] init] autorelease];
        @autoreleasepool { // r2 = push()
            for (int i = 0; i < 3; i++) {
                NSObject *obj3 = [[[NSObject alloc] init] autorelease];
            }
            @autoreleasepool { // r3 = push()
                NSObject *obj4 = [[[NSObject alloc] init] autorelease];
                _objc_autoreleasePoolPrint();
            } // pop(r3)
        } // pop(r2)
    } // pop(r1)
    return 0;
}

objc[1602]: ##############
objc[1602]: AUTORELEASE POOLS for thread 0x1000d2dc0
objc[1602]: 9 releases pending.
objc[1602]: [0x10100b000]  ................  PAGE  (hot) (cold)
objc[1602]: [0x10100b038]  ################  POOL 0x10100b038
objc[1602]: [0x10100b040]       0x10066e1f0  NSObject
objc[1602]: [0x10100b048]       0x10066d5d0  NSObject
objc[1602]: [0x10100b050]  ################  POOL 0x10100b050
objc[1602]: [0x10100b058]       0x10066d140  NSObject
objc[1602]: [0x10100b060]       0x10066c8d0  NSObject
objc[1602]: [0x10100b068]       0x100666de0  NSObject
objc[1602]: [0x10100b070]  ################  POOL 0x10100b070
objc[1602]: [0x10100b078]       0x100665f50  NSObject
objc[1602]: ##############
Program ended with exit code: 0

每页AutoreleasePoolPage可以容纳(4096 - 56)/8 = 505 个对象，第一页会加入一个特殊的对象边界。也就是说第一页可以加 504个自己的对象，之后的都是505个。

Runloop和Autorelease

MRC环境
iOS在主线程的Runloop中注册了2个Observer
第1个Observer监听了kCFRunLoopEntry事件，会调用objc_autoreleasePoolPush()
第2个Observer
监听了kCFRunLoopBeforeWaiting事件，会调用objc_autoreleasePoolPop()、objc_autoreleasePoolPush()
监听了kCFRunLoopBeforeExit事件，会调用objc_autoreleasePoolPop()
ARC环境
出了方法后，ARC会对方法里的局部对象调用release，对象会被立即释放

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 160,026评论 4赞 364
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 67,655评论 1赞 296
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 109,726评论 0赞 244
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 44,204评论 0赞 213
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 52,558评论 3赞 287
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 40,731评论 1赞 222
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 31,944评论 2赞 314
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 30,698评论 0赞 203
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 34,438评论 1赞 246
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 30,633评论 2赞 247
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 32,125评论 1赞 260
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 28,444评论 3赞 255
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 33,137评论 3赞 238
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 26,103评论 0赞 8
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,888评论 0赞 197
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 35,772评论 2赞 276
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 35,669评论 2赞 271