0
点赞
收藏
分享

微信扫一扫

学习笔记：@weakify(self) 和 @strongify(self) 和 __weak、__strong等

代码敲到深夜 2021-09-19 阅读 89
.技术流.iOSiOS深入原理

一、修饰符

ARC 环境下，所有的修饰符有以下4种

  • __strong修饰符
  • __weak修饰符
  • __unsafe_unretained修饰符
  • __autoreleasing 修饰符
  • 底层都是被函数objc_ownership(xxx)修饰，不同的修饰符，入参xxx不同。
    __strong ---> objc_ownership(strong)
    __weak ---> objc_ownership(weak)
    __unsafe_unretained ---> objc_ownership(none)
    __autoreleasing ---> objc_ownership(autoreleasing)

1.1、以__weak为例

#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
    NSString *str = @"helloworld";
    id __weak objc = str;
    NSLog(@"%@", objc);
    return 0;
}

注意： clang -rewrite-objc main.m 会报错，需要用以下替换。
clang -rewrite-objc -fobjc-arc -stdlib=libc++ -mmacosx-version-min=10.7 -fobjc-runtime=macosx-10.7 -Wno-deprecated-declarations weak.m

int main(int argc, const char * argv[]) {
    NSString *str = (NSString *)&__NSConstantStringImpl__var_folders_jf_zkvr_3r17rl3q1fw6zhz6jr40000gn_T_weak_cfe516_mi_0;
    
    // id __weak objc = str;
    id __attribute__((objc_ownership(weak))) objc = str;
    
    NSLog((NSString *)&__NSConstantStringImpl__var_folders_jf_zkvr_3r17rl3q1fw6zhz6jr40000gn_T_weak_cfe516_mi_1, objc);
    return 0;
}

二、__weak和__strong 的原理

2.1、__weak原理

1、基础知识
  • 最大作用是防止循环引用，当属性对象被释放的时候，weak属性会自动置为nil。
2、原理解释

Runtime维护了一个SideTable的hash表，Key是所指对象的地址，Value是一张weak_table_t的哈希数组，用来存储weak_entry_t的弱引用对象；其中weak_entry_t也是一个hash结构，如果存储的弱引用个数少于一定个数，就用静态数组存储；如果超过则用动态数组存储。

3、源码解析

在以下代码处断点，开启汇编窗口(Debug -> Debug Wokflow -> Always Show Disassembly ):

id __weak obj = str;

发现底层调用了objc_initWeak函数，查找源码，其实现如下

/** 
 * Initialize a fresh weak pointer to some object location. 
 * It would be used for code like: 
 *
 * (The nil case) 
 * __weak id weakPtr;
 * (The non-nil case) 
 * NSObject *o = ...;
 * __weak id weakPtr = o;
 * 
 * This function IS NOT thread-safe with respect to concurrent 
 * modifications to the weak variable. (Concurrent weak clear is safe.)
 *
 * @param location Address of __weak ptr.   // __weak指针 的地址 ，存储指针的地址。
 * @param newObj Object ptr.  // 所引用的对象，即例子中的obj 。
 */
id objc_initWeak(id *location, id newObj) {
    if (!newObj) {
        *location = nil;
        return nil;
    }

    return storeWeak<DontHaveOld, DoHaveNew, DoCrashIfDeallocating>
        (location, (objc_object*)newObj);
}
  • 总结：__weak 底层函数调用objc_initWeak() ---> objc_storeWeak()。
    objc_storeWeak() 的作用是更新指针指向，然后创建对应的弱引用表。

注意：实现原理在于理解 objc_storeWeak()函数的实现，详细可见 iOS底层原理：weak的实现原理 。

5、理解weak实现原理，重点理解内部的存储结构：
struct SideTable {
    weak_table_t weak_table;
};

struct weak_table_t {
    weak_entry_t *weak_entries;
    size_t    num_entries;
};

// weak对象实体存储结构体
struct weak_entry_t {
    DisguisedPtr<objc_object> referent;
    // 联合体
    union {
        struct {
            // 动态数组
            weak_referrer_t *referrers;
            uintptr_t        out_of_line_ness : 2;
            uintptr_t        num_refs : PTR_MINUS_2;
            uintptr_t        mask;
            uintptr_t        max_hash_displacement;
        };
        struct {
            // 定长数组
            // out_of_line_ness field is low bits of inline_referrers[1]
            weak_referrer_t  inline_referrers[WEAK_INLINE_COUNT]; 
        };
    };
    
    // 用来判断采用哪种存储方式（定长数组 或 动态数组）
   // 当弱引用该对象的指针数目小于等于WEAK_INLINE_COUNT时，使用定长数组。
   // 当超过WEAK_INLINE_COUNT时，会将定长数组中的元素转移到动态数组中，并之后都是用动态数组存储。
    bool out_of_line() {
        return (out_of_line_ness == REFERRERS_OUT_OF_LINE);
    }

    weak_entry_t& operator=(const weak_entry_t& other) {
        memcpy(this, &other, sizeof(other));
        return *this;
    }

    // 初始化 弱引用对象 数组
    weak_entry_t(objc_object *newReferent, objc_object **newReferrer)
        : referent(newReferent)
    {
        inline_referrers[0] = newReferrer;
        for (int i = 1; i < WEAK_INLINE_COUNT; i++) {
            inline_referrers[i] = nil;
        }
    }
};

// weak_referrer_t类型：DisguisedPtr泛型类，这里面类型是 objc_object
typedef DisguisedPtr<objc_object *> weak_referrer_t;

借用别人整理的图如下：


6、weak 原理概述：可以概括以下三步：

  • 1、初始化__weak对象的时候，底层会调用objc_initWeak函数，objc_initWeak函数内部又会调用 objc_storeWeak() 函数。

  • 2、objc_storeWeak() 函数，会在底层创建一张weak_table_t结构的hash表，key是所指对象的地址，value是weak指针的地址数组，数组存放的是weak_entry_t 的weak对象。

  • 3、对象释放时，调用clearDeallocating()函数根据对象地址获取所有weak指针地址的数组，然后遍历这个数组把其中的数据设为nil，最后把这个entry从weak表中删除，最后清理对象的记录。。

2.2、__strong

其修饰的对象引用计数器会+1，避免在block执行的时候，对象被提前释放了。

2.3、__weak 和 __strong 的应用

  • block外使用：__weak typeof(self) weakSelf = self;
    block捕获的是weakSelf，而其会在对象dealoc的时候，自动被释放置为nil，因此打破循环引用。

  • block内使用：__strong typeof(weakSelf) strongSelf = weakSelf;
    1、block 内的代码在__MyObject__test_block_func_0函数内，当使用strongSelf时，会先取出__weak修饰的成员变量self。
    2、然后再生成一个__strong修饰的局部变量，这时候 self 的引用计数 +1。
    3、这样的目的是在 block 内的代码块执行完之前避免 self 被dealloc掉。当 block 执行完毕之后，局部变量 strongSelf 被释放，self 的引用计数 -1。

三、关于RAC的奇妙宏@weakify(self) 和 @strongify(self)

宏的使用过程很精妙，有兴趣可以查看
深入研究 Block 用 weakSelf、strongSelf、@weakify、@strongify 解决循环引用
Reactive Cocoa中的@weakify、@strongify是如何装逼

  • 两个宏的作用等同于：
@weakify(self) = @autoreleasepool{} __weak __typeof__ (self) self_weak_ = self;
@strongify(self) = @autoreleasepool{} __strong __typeof__(self) self = self_weak_;
5.1、@weakify(self) 和 @strongify(self) 的原理分析
#import <Foundation/Foundation.h>

@interface MyObject : NSObject {
    NSString *_age;
}
@property (nonatomic, strong) NSString *name;
@property (nonatomic, copy) dispatch_block_t actionBlock;
@end

@implementation MyObject
- (void)dealloc {
    NSLog(@"MyObject Dealloc");
}

- (void)test {
    self.name = @"n";
    _age = @"10";

    @autoreleasepool{} __weak __typeof__ (self) self_weak_ = self; // @weakify(self)
    void(^textBlock)(void) = ^{
        @autoreleasepool{} __strong __typeof__(self) self = self_weak_; // @strongify(self)
        _age = @"11"; // 会导致循环引用

        //self.name = @"a"; // 不会导致循环引用
        //self->_age = @"23"; // 不会导致循环引用
    };

    textBlock();
    self.actionBlock = textBlock;
}
@end
  • clang -rewrite-objc -fobjc-arc -fobjc-runtime=macosx-10.14 filename 查看底层代码。
struct __MyObject__test_block_impl_0 {
  struct __block_impl impl;
  struct __MyObject__test_block_desc_0* Desc;

  MyObject *const __weak self_weak_; // 捕获的是self_weak_

  __MyObject__test_block_impl_0(void *fp, struct __MyObject__test_block_desc_0 *desc, MyObject *const __weak _self_weak_, int flags=0) : self_weak_(_self_weak_) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __MyObject__test_block_func_0(struct __MyObject__test_block_impl_0 *__cself) {
  MyObject *const __weak self_weak_ = __cself->self_weak_; // bound by copy

    /* @autoreleasepool */{ __AtAutoreleasePool __autoreleasepool; } __attribute__((objc_ownership(strong))) __typeof__(self) self = self_weak_;
    (*(NSString *__strong *)((char *)self + OBJC_IVAR_$_MyObject$_age)) = (NSString *)&__NSConstantStringImpl__var_folders_jf_zkvr_3r17rl3q1fw6zhz6jr40000gn_T_person_a08aad_mi_3;
}

  • block默认捕获self是强引用（MyObject *const __strong self;）；而使用上面修饰后@weakify(self)，block内部捕获的是MyObject *const __weak self_weak_;，因此打破了循环引用。

  • 注意1：block内部如果使用_name方式引用，也会导致循环引用；必须通过self.name 或者 self->name才能打破循环引用。
    具体原因，网上有人是说对self和self_weak_都进行了捕获，可是clang之后的代码没有发现显示引用，有待研究。

  • 注意2：@weakify和@strongify必须都使用。
    测试发现如果只使用@weakify，而不调@ strongify一样会导致循环引用。原因是这种情况下捕获的还是self，而不是self_weak_。

struct __MyObject__test_block_impl_0 {
  struct __block_impl impl;
  struct __MyObject__test_block_desc_0* Desc;
  MyObject *const __strong self;
  __MyObject__test_block_impl_0(void *fp, struct __MyObject__test_block_desc_0 *desc, MyObject *const __strong _self, int flags=0) : self(_self) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __MyObject__test_block_func_0(struct __MyObject__test_block_impl_0 *__cself) {
  MyObject *const __strong self = __cself->self; // bound by copy
  ((void (*)(id, SEL, NSString *))(void *)objc_msgSend)((id)self, sel_registerName("setName:"), (NSString *)&__NSConstantStringImpl__var_folders_jf_zkvr_3r17rl3q1fw6zhz6jr40000gn_T_person_2fca58_mi_3);
}

参考

iOS 底层解析weak的实现原理

举报

相关推荐

ARC指南 strong和weak指针

Objective Cjava编译器内存管理Java编程语言

strong、weak和unowned的区别

Objective-C程序员iOS 开发每...

关于OC中self和super的笔记

日记本

Swift 元类型和.self

日记本Swift学习swift

javascript的self和this使用小结

执行环境window对象javascriptJava编程语言

Self-Attention（笔记，自用）

深度学习自然语言处理transformer

transformer和self-attention的关系

后端javaspringmybatismavenspring boot

Attention 和 self-attention 的区别

自然语言处理transformer深度学习

pytroch中ctx和self的区别

python静态方法自定义实例化OpenStack云计算

iOS 对self和super的理解

iOS
0 条评论