runtime_runtimeexception - CSDN
精华内容
参与话题
  • Runtime 基本介绍(一)

    千次阅读 2018-10-15 14:09:36
    1.Runtime是什么 Runtime又叫运行时,是iOS内部核心之一,起底层实现是C语言,平时调用的活着编写的OC代码,底层基本都是基于Runtime实现的。比如: [rereiver message];底层运行时会被编译器自动转为:objc_...

    1.Runtime是什么

    Runtime又叫运行时,是iOS内部核心之一,起底层实现是C语言,平时调用的活着编写的OC代码,底层基本都是基于Runtime实现的。比如:

    [rereiver message];底层运行时会被编译器自动转为:objc_msgSend(recveiver,selector); 如果带有参数的话:[receeiver message:(id)arg...]; 底层运行时会被编译器转为:objc_msgSend(receiver,selector,arg1,arg2...)

    2.使用Runtime 的原因

    1.OC 是一门动态语言,他将一部分工作放在了运行时才处理而不是编译时处理。有很多类和成员变量在编译时我们时不知道的,而在运行时,我们所编写的代码才会转换成完整的确定的代码去运行。因此,仅仅只有一套编译器是不够的额,还需要一套运行时系统(Runtime System)来处理编译后的工作。

    2.Runtime 基本是用C语言和汇编语言来编写的,动态系统使用高效。

    3.Runtime的作用

    OC 在三种层面上与Runtime 系统进行交互

    1.通过OC源代码

    只需要编写OC代码,Runtime系统自动在幕后搞定一些,调用方法,编译器会将OC代码转换成运行时代吗,在运行时确定数据结构和函数。

    2.通过对 Runtime库函数的直接调用

    Runtime系统具有公共接口的动态共享库,头文件存在于/usr/include/objc目录下,这意味着我们使用时只需要引入objc/Runtime.h头文件即可。许多函数可以让你使用C代码来实现Objc同样的功能。除非是写一些Objc与其他语言的桥接或着是底层的debug工作,你在写Objc代码时,一般不会用到这些C语言函数。

    3.通过Foundation框架的NSObject类来定义的方法

    Cocoa程序中绝大部分类都是NSObject类的子类,所以都继承了NSObject的行为。(NSProxy类是个例外,他是个抽象类)。一些情况下,NSObject类仅仅定义了完成某件事情的模版,并没有提供所需要的代码。例如 - description方法,该方法返回类内容的字符串表示,该方法主要用来调试程序。NSObject类并不知道子类的内容,所以他只返回类的名字和对象的地址,NSObjecta的子类,可以重新实现。

    还有一些NSObject的方法,可以从Runtime系统中获取信息,允许对象进行自我检查。例如:

    -class 方法返回当前对象的类

    -isKindOfClass:和-isMemberOfClass:方法检查对象是否存在于指定的类的额继承体系中(是否是其子类或着父类或着当前类的成员变量);

    -responseToSelector:检查对象是否响应指定的消息;

    -conformsToProtocol:  检查对象是否实现了指定协议类的方法;

    -methodForSelector: 返回指定方法实现的地址。

     

    本文来源自其他文章

     

     

    展开全文
  • runtime一般用法和原理

    千次阅读 2018-07-31 14:54:44
    runtime概念: Objective-C 是基于 C 的,它为 C 添加了面向对象的特性。它将很多静态语言在编译和链接时期做的事放到了 runtime 运行时来处理,可以说 runtime 是我们 Objective-C 幕后工作者。 runtime(简称...

    runtime概念:

    Objective-C 是基于 C 的,它为 C 添加了面向对象的特性。它将很多静态语言在编译和链接时期做的事放到了 runtime 运行时来处理,可以说 runtime 是我们 Objective-C 幕后工作者。

    runtime(简称运行时),是一套 纯C(C和汇编写的) 的API。而 OC 就是 运行时机制,也就是在运行时候的一些机制,其中最主要的是 消息机制。

    对于 C 语言,函数的调用在编译的时候会决定调用哪个函数。

    OC的函数调用成为消息发送,属于 动态调用过程。在编译的时候并不能决定真正调用哪个函数,只有在真正运行的时候才会根据函数的名称找到对应的函数来调用。

    事实证明:在编译阶段,OC 可以 调用任何函数,即使这个函数并未实现,只要声明过就不会报错,只有当运行的时候才会报错,这是因为OC是运行时动态调用的。而 C 语言 调用未实现的函数 就会报错。

    runtime消息机制

    我们写 OC 代码,它在运行的时候也是转换成了 runtime 方式运行的。任何方法调用本质:就是发送一个消息(用 runtime发送消息,OC 底层实现通过 runtime 实现)。

    消息机制原理:对象根据方法编号SEL去映射表查找对应的方法实现。

    每一个 OC 的方法,底层必然有一个与之对应的 runtime 方法。

    OC–>runtime

    简单示例:

    验证:方法调用,是否真的是转换为消息机制?

    必须要导入头文件 #import

    Person *p = objc_msgSend(objc_getClass("Person"), sel_registerName("alloc"));
    // p = [p init];
    p = objc_msgSend(p, sel_registerName("init"));
    // 调用对象方法(本质:让对象发送消息)
    //[p eat];
    // 本质:让类对象发送消息
    objc_msgSend(p, @selector(eat));
    objc_msgSend([Person class], @selector(run:),20);

    //————————— <#我是分割线#> ——————————//

    // 也许下面这种好理解一点
    
    // id objc = [NSObject alloc];
    
    id objc = objc_msgSend([NSObject class], @selector(alloc));
    // objc = [objc init];
    
    objc = objc_msgSend(objc, @selector(init));

    runtime 方法调用流程「消息机制」

    面试:消息机制方法调用流程

    怎么去调用eat方法,对象方法:(保存到类对象的方法列表) ,类方法:(保存到元类(Meta Class)中方法列表)。

    1.OC 在向一个对象发送消息时,runtime 库会根据对象的 isa指针找到该对象对应的类或其父类中查找方法。。

    2.注册方法编号(这里用方法编号的好处,可以快速查找)。

    3.根据方法编号去查找对应方法。

    4.找到只是最终函数实现地址,根据地址去方法区调用对应函数。

    补充:一个objc 对象的 isa 的指针指向什么?有什么作用?

    每一个对象内部都有一个isa指针,这个指针是指向它的真实类型,根据这个指针就能知道将来调用哪个类的方法。

    runtime常见作用

    • 动态交换两个方法的实现

    • 动态添加属性

    • 实现字典转模型的自动转换

    • 动态添加方法

    • 拦截并替换方法

    1、动态交换两个方法

    现在要实现一个加载图片的时候,输出当前图片是否存在或者是否下载成功

    (1)创建个UIImage的分类UIImage+extension
    (2)实现一个自定义方法

    +(UIImage )In_imageName:(NSString )name;
    (3)在+ (void)load方法里面进行方法交换

    首先在UIImage+extension.h文件里

    @interface UIImage (extension)
    +(UIImage *)In_imageName:(NSString *)name;
    @end

    然后在.m文件里:

    #import "UIImage+URL.h"
    #import <objc/runtime.h>
    
    @implementation UIImage (URL)
    + (void)load{
    //    获取image的系统方法imageWithName
        Method imageWithName = class_getClassMethod([UIImage class], @selector(imageNamed:));
    //    获取自定义的In_ImageName方法
        Method In_imageName = class_getClassMethod([UIImage class], @selector(In_imageName:));
    //    交换两个方法的指针地址,相当于交换两个方法的实现
        method_exchangeImplementations(In_imageName, imageWithName);
    }
    
    /**
     *这个方法内部实现并不会产生循环引用,因为在load方法中,imageName:的方法和In_imageName:的实现进行了交换,调用In_imageName:其实是调用imageName:方法
     */
    +(UIImage *)In_imageName:(NSString *)name{
        UIImage * image = [UIImage In_imageName:name];
        if (image == nil) {
            NSLog(@"image加载错误");
        }
        return image;
    }
    @end

    上面的代码中,最关键的代码就是+ (void)load方法里面的

    //    获取image的系统方法imageWithName,代码1
        Method imageWithName = class_getClassMethod([UIImage class], @selector(imageNamed:));
    //    获取自定义的In_ImageName方法,代码2
        Method In_imageName = class_getClassMethod([UIImage class], @selector(In_imageName:));
    //    交换两个方法的指针地址,相当于交换两个方法的实现,代码3
        method_exchangeImplementations(In_imageName, imageWithName);

    class_getClassMethod方法是获取类里面的方法,这个需要传入两个类,一个就是想要获取那个类的方法,比如[uiimage class] ,第二个参数为SEL,这个是获取什么方法;

    代码1获取的是UIImage里面的imageNamed:方法
    代码2获取的是UIImage里面自定义的In_imageNamed:方法
    代码3是交换两个方法的实现地址,也就是实现imageNamed:的时候,会指向In_imageNamed:的实现方法

    2、动态添加属性

    原理:给一个类声明属性,其实本质就是给这个类添加关联,并不是直接把这个值的内存空间添加到类存空间。

    应用场景:给系统的类添加属性的时候,可以使用runtime动态添加属性方法。

    注解:系统 NSObject 添加一个分类,我们知道在分类中是不能够添加成员属性的,虽然我们用了@property,但是仅仅会自动生成get和set方法的声明,并没有带下划线的属性和方法实现生成。但是我们可以通过runtime就可以做到给它方法的实现。

    需求:给系统 NSObject 类动态添加属性 name 字符串。

    下面是代码实现:
    .h

    @interface NSObject (Property)
    /*注释*/
    @property (nonatomic , copy) NSString *name;
    @end

    一般定义一个属性后,系统就会自动生成set、get方法,但是在分类中定义一个属性后,是不会自动生成set get方法的,会提示:
    这里写图片描述
    所以这个时候就需要自我生成set、get方法,oc是运行时机制,所以要才有runtime的机制下set、get属性
    .m

    - (NSString *)name{
        return objc_getAssociatedObject(self, @"name");
    }
    
    -(void)setName:(NSString *)name{
        // objc_setAssociatedObject(将某个值跟某个对象关联起来,将某个值存储到某个对象中)
        // object:给哪个对象添加属性
        // key:属性名称
        // value:属性值
        // policy:保存策略
        objc_setAssociatedObject(self, @"name", name, OBJC_ASSOCIATION_COPY_NONATOMIC);
    }

    调用:

        NSObject *objc = [[NSObject alloc] init];
        objc.name = @"huhuhu";
        NSLog(@"runtime动态添加属性:%@",objc.name);

    打印结果:
    这里写图片描述

    3、实现字典转模型

    这个在上个博客中专门提过,这里是链接:runtime实现json转model模型

    4、动态添加方法

    runtime动态添加方法的实质是在performSelector:一个方法后,在运行的时候没有查找到这个方法,如果是实例方法,则会走到

    • (BOOL)resolveInstanceMethod:(SEL)sel;
      如果是类方法,则会走到:
    • (BOOL)resolveClassMethod:(SEL)sel;

    在这里面,可以给开发者多一次处理当前选择的方法没找到的情况,我们则在这里添加一个新方法取代掉选择的方法;

    我们调用一个Person类中没有声明的方法:

    [person performSelector:@selector(jump) withObject:@"20"];

    Person.h中没有定义方法;
    Person.m中:
    首先定义一个要添加的方法:

    void jump2(id self,SEL sel, NSString* metter){
        NSLog(@"跳了%@米",metter);
    }

    任何方法默认都有两个隐式参数,self,_cmd(当前方法的方法编号)

    然后在

    /**
     *动态添加方法,其实就是在调用的方法找不到的时候,会走到这个方法下面,可以根据自己的需求来添加具体的方法
     *@param sel 这个其实就是自己选择的方法
     */
    + (BOOL)resolveInstanceMethod:(SEL)sel{
        NSString * selStr = NSStringFromSelector(sel);
        if ([selStr isEqualToString:@"jump"]) {
            class_addMethod([Person class], sel, (IMP)jump2, "v@:@");
            return YES;
        }
        return NO;
    }

    class_addMethod参数说明:
    第一个参数:是给那个类添加方法;如[Person class]
    第二个参数:就是哪个方法找不到或者没有实现,这里指的就是jump方法
    第三个参数:是要添加的方法指针,这里是jump2方法指针
    第四个参数:就是返回值了,:左边是返回值,右边是参数V@:@指的是返回的是void,参数是NSString;

    打印结果是:
    这里写图片描述

    5、动态变量控制

    现在有一个Person类,创建 xiaoming对象
    动态获取 XiaoMing 类中的所有属性 [当然包括私有]

    ivar *ibarList = class_copyIvarList([self.xiaoming class],&count);

    遍历所有的属性列表,找到age属性,修改age为20

    const char *varName = ivar_getName(var);
    object_setIvar(self.xiaoMing, var, @"20");

    具体代码:

        Person * xiaoming = [[Person alloc] init];
    //    获取xiaoming中的所有属性(包括私有的)
        unsigned int count;
        Ivar *ivarList = class_copyIvarList([xiaoming class], &count);
    //    遍历所有的属性
        for (int i = 0; i < count; i++) {
    //        根据下标获取具体属性
            Ivar ivar = ivarList[i];
    //        获取属性名称
            const char* property = ivar_getName(ivar);
            NSString * propertyName = [NSString stringWithUTF8String:property];
    //        判断当前属性是不是age
            if ([propertyName isEqualToString:@"_age"]) {
                object_setIvar(xiaoming, ivar, @"30");
                break;
            }
    
        }
        NSLog(@"动态控制变量age = %@",xiaoming.age);

    打印结果:
    这里写图片描述


    runtime的一些使用方法暂时分享到这里,后续会继续更新;欢迎关注

    展开全文
  • 1. runtime(运行时机制)是什么? 2. runtime可以用来做什么? 3. runtime相关的头文件和函数

    很多关于runtime的博客文章都是开篇介绍runtime原理、消息传递机制等等,让好多的同学望而生畏。对于runtime这个强大的略带神秘色彩的独特处理机制,我们需要循序渐进。

    刚开始接触runtime,先让我们揭开它的神秘面纱,不去想原理,不要想太多,只是简单的认识一下。

    runtime(运行时机制)是什么

    runtime是属于OC的底层,是一套比较底层的纯C语言API, 属于1个C语言库, 包含了很多底层的C语言API,可以进行一些非常底层的操作(用OC是无法现实的, 不好实现)。 在我们平时编写的OC代码中, 程序运行过程时, 其实最终都是转成了runtime的C语言代码, runtime算是OC的幕后工作者。

    举例:

    //OC : 
    [[MJPerson alloc] init] 
    //runtime : 
    objc_msgSend(objc_msgSend("MJPerson" , "alloc"), "init")

    runtime可以用来做什么

    1. 在程序运行过程中,动态创建一个类(比如KVO的底层实现)
    2. 在程序运行过程中,动态地为某个类添加属性/方法。可以用于封装框架(想怎么改就怎么改) 这就是我们runtime机制的主要运用方向
    3. 遍历一个类中所有的成员变量(属性)/所有方法。(比如字典–>模型:利用runtime遍历模型对象的所有属性, 根据属性名从字典中取出对应的值, 设置到模型的属性上;还有归档和接档,利用runtime遍历模型对象的所有属性)

    runtime相关头文件和函数

    利用头文件,我们可以查看到runtime中的各个方法!

    <objc/runtime.h>
    <objc/message.h> 

    相关函数:

     objc_msgSend : 给对象发送消息
     class_copyMethodList : 遍历某个类所有的方法
     class_copyIvarList : 遍历某个类所有的成员变量
     class_..... 

    必备常识

    • Ivar : 成员变量
    • Method : 成员方法

    接下来,我们来看看苹果官方文档对于runtime的介绍,不要担心,我已经翻译好了:runtime官方文档翻译

    展开全文
  • 前言 提起弱引用,大家都知道它的作用: (1)不会添加引用计数 (2)当所引用的对象释放后,引用者的指针自动置为nil 那么,围绕它背后的实现,是怎么样的呢?在许多公司面试时,都会问到这个问题。...

    前言

    提起弱引用,大家都知道它的作用:
    (1)不会添加引用计数 (2)当所引用的对象释放后,引用者的指针自动置为nil
    那么,围绕它背后的实现,是怎么样的呢?在许多公司面试时,都会问到这个问题。那么,今天就带大家一起分析一下weak引用是怎么实现的,希望能够搞清楚每一个细节。

    Store as weak

    当我们要weak引用一个对象,我们可以这么做:

    int main(int argc, char * argv[]) {
        @autoreleasepool {
            NSObject *obj = [[NSObject alloc] init];
            __weak NSObject *weakObj = obj;
        }
    }
    

    创建了一个NSObject对象obj,然后用weakObj对obj做弱引用。
    当我们对一个对象做weak引用的时候,其背后是通过runtime来支持的。当把一个对象做weak引用时,会调用runtime方法objc_initWeak

    objc_initWeak

    id objc_initWeak(id *location, id newObj)
    {
        if (!newObj) {
            *location = nil;
            return nil;
        }
    
        return storeWeak<DontHaveOld, DoHaveNew, DoCrashIfDeallocating>
            (location, (objc_object*)newObj);
    }
    

    该方法接受两个参数:

    • id *location :__weak指针的地址,即例子中的weak指针取地址: &weakObj它是一个指针的地址。之所以要存储指针的地址,是因为最后我们要讲__weak指针指向的内容置为nil,如果仅存储指针的话,是不能够完成这个功能的。
    • id newObj :所引用的对象。即例子中的obj

    有一个返回值 id : 会返回obj自身,但其值已经做了更改(isa_t中的weak_ref位置1),参见Objective-C runtime机制(5)——iOS 内存管理

    objc_initWeak实质是调用了storeWeak方法。看这个方法的名字,就可以猜到是将weak引用存到某个地方,没错,实际上苹果就是这么做的。

    storeWeak

    storeWeak方法有点长,这也是weak引用的核心实现部分。其实核心也就实现了两个功能:

    • 将weak指针的地址location存入到obj对应的weak_entry_t的数组(链表)中,用于在obj析构时,通过该数组(链表)找到所有其weak指针引用,并将指针指向的地址(location)置为nil。关于weak_entry_t,在上一篇中已有介绍。

    • 如果启用了isa优化,则将obj的isa_tweakly_referenced位置1。置位1的作用主要是为了标记obj被weak引用了,当dealloc时,runtime会根据weakly_referenced标志位来判断是否需要查找obj对应的weak_entry_t,并将引用置为nil

    // Template parameters.
    enum HaveOld { DontHaveOld = false, DoHaveOld = true };
    enum HaveNew { DontHaveNew = false, DoHaveNew = true };
    enum CrashIfDeallocating {
        DontCrashIfDeallocating = false, DoCrashIfDeallocating = true
    };
    
    template <HaveOld haveOld, HaveNew haveNew,
              CrashIfDeallocating crashIfDeallocating>
    static id 
    storeWeak(id *location, objc_object *newObj)
    {
        assert(haveOld  ||  haveNew);
        if (!haveNew) assert(newObj == nil);
    
        Class previouslyInitializedClass = nil;
        id oldObj;
        SideTable *oldTable;
        SideTable *newTable;
    
        // Acquire locks for old and new values.
        // Order by lock address to prevent lock ordering problems. 
        // Retry if the old value changes underneath us.
     retry:
        if (haveOld) { // 如果weak ptr之前弱引用过一个obj,则将这个obj所对应的SideTable取出,赋值给oldTable
            oldObj = *location;
            oldTable = &SideTables()[oldObj];
        } else {
            oldTable = nil; // 如果weak ptr之前没有弱引用过一个obj,则oldTable = nil
        }
        if (haveNew) { // 如果weak ptr要weak引用一个新的obj,则将该obj对应的SideTable取出,赋值给newTable
            newTable = &SideTables()[newObj];
        } else {
            newTable = nil; // 如果weak ptr不需要引用一个新obj,则newTable = nil
        }
        
        // 加锁操作,防止多线程中竞争冲突
        SideTable::lockTwo<haveOld, haveNew>(oldTable, newTable);
    
        // location 应该与 oldObj 保持一致,如果不同,说明当前的 location 已经处理过 oldObj 可是又被其他线程所修改
        if (haveOld  &&  *location != oldObj) {
            SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
            goto retry;
        }
    
        // Prevent a deadlock between the weak reference machinery
        // and the +initialize machinery by ensuring that no 
        // weakly-referenced object has an un-+initialized isa.
        if (haveNew  &&  newObj) {
            Class cls = newObj->getIsa();
            if (cls != previouslyInitializedClass  &&  
                !((objc_class *)cls)->isInitialized())  // 如果cls还没有初始化,先初始化,再尝试设置weak
            {
                SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
                _class_initialize(_class_getNonMetaClass(cls, (id)newObj));
    
                // If this class is finished with +initialize then we're good.
                // If this class is still running +initialize on this thread 
                // (i.e. +initialize called storeWeak on an instance of itself)
                // then we may proceed but it will appear initializing and 
                // not yet initialized to the check above.
                // Instead set previouslyInitializedClass to recognize it on retry.
                previouslyInitializedClass = cls; // 这里记录一下previouslyInitializedClass, 防止改if分支再次进入
    
                goto retry; // 重新获取一遍newObj,这时的newObj应该已经初始化过了
            }
        }
    
        // Clean up old value, if any.
        if (haveOld) {
            weak_unregister_no_lock(&oldTable->weak_table, oldObj, location); // 如果weak_ptr之前弱引用过别的对象oldObj,则调用weak_unregister_no_lock,在oldObj的weak_entry_t中移除该weak_ptr地址
        }
    
        // Assign new value, if any.
        if (haveNew) { // 如果weak_ptr需要弱引用新的对象newObj
            // (1) 调用weak_register_no_lock方法,将weak ptr的地址记录到newObj对应的weak_entry_t中
            newObj = (objc_object *)
                weak_register_no_lock(&newTable->weak_table, (id)newObj, location, 
                                      crashIfDeallocating);
            // weak_register_no_lock returns nil if weak store should be rejected
            
            // (2) 更新newObj的isa的weakly_referenced bit标志位
            // Set is-weakly-referenced bit in refcount table.
            if (newObj  &&  !newObj->isTaggedPointer()) {
                newObj->setWeaklyReferenced_nolock();
            }
    
            // Do not set *location anywhere else. That would introduce a race.
            // (3)*location 赋值,也就是将weak ptr直接指向了newObj。可以看到,这里并没有将newObj的引用计数+1
            *location = (id)newObj; // 将weak ptr指向object
        }
        else {
            // No new value. The storage is not changed.
        }
        
        // 解锁,其他线程可以访问oldTable, newTable了
        SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
    
        return (id)newObj; // 返回newObj,此时的newObj与刚传入时相比,weakly-referenced bit位置1
    }
    

    下面我们就一起来分析下storeWeak方法。

    storeWeak方法实质上接受5个参数,其中HaveOld haveOld, HaveNew haveNew, CrashIfDeallocating crashIfDeallocating 这三个参数是以模板枚举的方式传入的,其实这是三个bool参数,分别表示:weak ptr之前是否已经指向了一个弱引用,weak ptr是否需要指向一个新引用, 如果被弱引用的对象正在析构,此时再弱引用该对象,是否应该crash。

    具体到objc_initWeak,这三个参数的值分别为falsetruetrue

    storeWeak 另外两个参数是id *location, objc_object *newObj,这两个参数和objc_initWeak是一样的,分别代表weak 指针的地址,以及被weak引用的对象。

    接下来函数体里的内容,大家可以结合注释,应该能够看个明白。

    这里涉及到两个关键的函数:

    weak_unregister_no_lock  // 将 weak ptr地址 从obj的weak_entry_t中移除
    weak_register_no_lock   // 将 weak ptr地址 注册到obj对应的weak_entry_t中
    

    这里我们先看注册函数:

    weak_register_no_lock

    id 
    weak_register_no_lock(weak_table_t *weak_table, id referent_id, 
                          id *referrer_id, bool crashIfDeallocating)
    {
        objc_object *referent = (objc_object *)referent_id;
        objc_object **referrer = (objc_object **)referrer_id;
    
        // 如果referent为nil 或 referent 采用了TaggedPointer计数方式,直接返回,不做任何操作
        if (!referent  ||  referent->isTaggedPointer()) return referent_id;
    
        // 确保被引用的对象可用(没有在析构,同时应该支持weak引用)
        bool deallocating;
        if (!referent->ISA()->hasCustomRR()) {
            deallocating = referent->rootIsDeallocating();
        }
        else {
            BOOL (*allowsWeakReference)(objc_object *, SEL) = 
                (BOOL(*)(objc_object *, SEL))
                object_getMethodImplementation((id)referent, 
                                               SEL_allowsWeakReference);
            if ((IMP)allowsWeakReference == _objc_msgForward) {
                return nil;
            }
            deallocating =
                ! (*allowsWeakReference)(referent, SEL_allowsWeakReference);
        }
        // 正在析构的对象,不能够被弱引用
        if (deallocating) {
            if (crashIfDeallocating) {
                _objc_fatal("Cannot form weak reference to instance (%p) of "
                            "class %s. It is possible that this object was "
                            "over-released, or is in the process of deallocation.",
                            (void*)referent, object_getClassName((id)referent));
            } else {
                return nil;
            }
        }
    
        // now remember it and where it is being stored
        // 在 weak_table中找到referent对应的weak_entry,并将referrer加入到weak_entry中
        weak_entry_t *entry;
        if ((entry = weak_entry_for_referent(weak_table, referent))) { // 如果能找到weak_entry,则讲referrer插入到weak_entry中
            append_referrer(entry, referrer); 	// 将referrer插入到weak_entry_t的引用数组中
        } 
        else { // 如果找不到,就新建一个
            weak_entry_t new_entry(referent, referrer);  
            weak_grow_maybe(weak_table);
            weak_entry_insert(weak_table, &new_entry);
        }
    
        // Do not set *referrer. objc_storeWeak() requires that the 
        // value not change.
    
        return referent_id;
    }
    

    注意看开头的地方:

     // 如果referent为nil 或 referent 采用了TaggedPointer计数方式,直接返回,不做任何操作
        if (!referent  ||  referent->isTaggedPointer()) return referent_id;
    

    这里再次出现了taggedPointer的身影,若引用计数使用了taggedPointer,则不会做任何引用计数。

    接着,会判断referent_id是否能够被weak 引用。这里主要判断referent_id是否正在被析构以及referent_id是否支持weak引用。如果referent_id不能够被weak引用,则直接返回nil。

    接下来,如果referent_id能够被weak引用,则将referent_id对应的weak_entry_tweak_table的weak_entry_t哈希数组中找出来,并将若

    entry = weak_entry_for_referent(weak_table, referent)
    

    如果entry不存在,则会新建一个referent_id所对应的weak_entry_t

        else { // 如果找不到,就新建一个
            weak_entry_t new_entry(referent, referrer);  // 创建一个新的weak_entry_t ,并将referrer插入到weak_entry_t的引用数组中
            weak_grow_maybe(weak_table);  // weak_table的weak_entry_t 数组是否需要动态增长,若需要,则会扩容一倍
            weak_entry_insert(weak_table, &new_entry); // 将weak_entry_t插入到weak_table中
        }
    

    将referrer插入到对应的weak_entry_t的引用数组后,我们的weak工作基本也就结束了。
    最后,只需要返回被引用的对象即可:

    return referent_id;
    

    关于referrer是如何插入到weak_entry_t中的,其hash算法是怎么样的,利用函数append_referrer:

    static void append_referrer(weak_entry_t *entry, objc_object **new_referrer)
    {
        if (! entry->out_of_line()) { // 如果weak_entry 尚未使用动态数组,走这里
            // Try to insert inline.
            for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {
                if (entry->inline_referrers[i] == nil) {
                    entry->inline_referrers[i] = new_referrer;
                    return;
                }
            }
            
            // 如果inline_referrers的位置已经存满了,则要转型为referrers,做动态数组。
            // Couldn't insert inline. Allocate out of line.
            weak_referrer_t *new_referrers = (weak_referrer_t *)
                calloc(WEAK_INLINE_COUNT, sizeof(weak_referrer_t));
            // This constructed table is invalid, but grow_refs_and_insert
            // will fix it and rehash it.
            for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {
                new_referrers[i] = entry->inline_referrers[i];
            }
            entry->referrers = new_referrers;
            entry->num_refs = WEAK_INLINE_COUNT;
            entry->out_of_line_ness = REFERRERS_OUT_OF_LINE;
            entry->mask = WEAK_INLINE_COUNT-1;
            entry->max_hash_displacement = 0;
        }
    
        // 对于动态数组的附加处理:
        assert(entry->out_of_line()); // 断言: 此时一定使用的动态数组
    
        if (entry->num_refs >= TABLE_SIZE(entry) * 3/4) { // 如果动态数组中元素个数大于或等于数组位置总空间的3/4,则扩展数组空间为当前长度的一倍
            return grow_refs_and_insert(entry, new_referrer); // 扩容,并插入
        }
        
        // 如果不需要扩容,直接插入到weak_entry中
        // 注意,weak_entry是一个哈希表,key:w_hash_pointer(new_referrer) value: new_referrer
        
        // 细心的人可能注意到了,这里weak_entry_t 的hash算法和 weak_table_t的hash算法是一样的,同时扩容/减容的算法也是一样的
        size_t begin = w_hash_pointer(new_referrer) & (entry->mask); // '& (entry->mask)' 确保了 begin的位置只能大于或等于 数组的长度
        size_t index = begin;  // 初始的hash index
        size_t hash_displacement = 0;  // 用于记录hash冲突的次数,也就是hash再位移的次数
        while (entry->referrers[index] != nil) {
            hash_displacement++;
            index = (index+1) & entry->mask;  // index + 1, 移到下一个位置,再试一次能否插入。(这里要考虑到entry->mask取值,一定是:0x111, 0x1111, 0x11111, ... ,因为数组每次都是*2增长,即8, 16, 32,对应动态数组空间长度-1的mask,也就是前面的取值。)
            if (index == begin) bad_weak_table(entry); // index == begin 意味着数组绕了一圈都没有找到合适位置,这时候一定是出了什么问题。
        }
        if (hash_displacement > entry->max_hash_displacement) { // 记录最大的hash冲突次数, max_hash_displacement意味着: 我们尝试至多max_hash_displacement次,肯定能够找到object对应的hash位置
            entry->max_hash_displacement = hash_displacement;
        }
        // 将ref存入hash数组,同时,更新元素个数num_refs
        weak_referrer_t &ref = entry->referrers[index];
        ref = new_referrer;
        entry->num_refs++;
    }
    

    weak_unregister_no_lock

    如果weak ptr在指向obj之前,已经weak引用了其他的对象,则需要先将weak ptr从其他对象的weak_entry_t的hash数组中移除。在storeWeak方法中,会调用weak_unregister_no_lock来做移除操作:

        if (haveOld) {
            weak_unregister_no_lock(&oldTable->weak_table, oldObj, location); // 如果weak_ptr之前弱引用过别的对象oldObj,则调用weak_unregister_no_lock,在oldObj的weak_entry_t中移除该weak_ptr地址
        }
    

    weak_unregister_no_lock的实现如下:

    void
    weak_unregister_no_lock(weak_table_t *weak_table, id referent_id, 
                            id *referrer_id)
    {
        objc_object *referent = (objc_object *)referent_id;
        objc_object **referrer = (objc_object **)referrer_id;
    
        weak_entry_t *entry;
    
        if (!referent) return;
    
        if ((entry = weak_entry_for_referent(weak_table, referent))) { // 查找到referent所对应的weak_entry_t
            remove_referrer(entry, referrer);  // 在referent所对应的weak_entry_t的hash数组中,移除referrer
           
            // 移除元素之后, 要检查一下weak_entry_t的hash数组是否已经空了
            bool empty = true;
            if (entry->out_of_line()  &&  entry->num_refs != 0) {
                empty = false;
            }
            else {
                for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {
                    if (entry->inline_referrers[i]) {
                        empty = false; 
                        break;
                    }
                }
            }
    
            if (empty) { // 如果weak_entry_t的hash数组已经空了,则需要将weak_entry_t从weak_table中移除
                weak_entry_remove(weak_table, entry);
            }
        }
    

    weak_unregister_no_lock的实现逻辑比较简单。

    1. 首先,它会在weak_table中找出referent对应的weak_entry_t
    2. 在weak_entry_t中移除referrer
    3. 移除元素后,判断此时weak_entry_t中是否还有元素 (empty==true?)
    4. 如果此时weak_entry_t已经没有元素了,则需要将weak_entry_t从weak_table中移除

    OK,上面的所有就是当我们将一个obj作weak引用时,所发生的事情。那么,当obj释放时,所有weak引用它的指针又是如何自动设置为nil的呢?接下来我们来看一下obj释放时,所发生的事情。

    Dealloc

    当对象引用计数为0时,runtime会调用_objc_rootDealloc方法来析构对象,实现如下:

    void
    _objc_rootDealloc(id obj)
    {
        assert(obj);
    
        obj->rootDealloc();
    }
    

    它会调用objc_objectrootDealloc方法:

    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);
        }
    }
    

    rootDealloc的实现逻辑如下:

    1. 判断object是否采用了Tagged Pointer计数,如果是,则不进行任何析构操作。关于这一点,我们可以看出,用Tagged Pointer计数的对象,是不会析构的。Tagged Pointer计数的对象在内存中应该是类似于字符串常量的存在,多个对象指针其实会指向同一块内存地址。虽然官方文档中并没有提及,但可以推测,Tagged Pointer计数的对象的内存位置很有可以就位于字符串常量区。
    2. 接下来判断对象是否采用了优化的isa计数方式(isa.nonpointer)。如果是,则判断是否能够进行快速释放(free(this) 用C函数释放内存)。可以进行快速释放的前提是:对象没有被weak引用!isa.weakly_referenced,没有关联对象!isa.has_assoc,没有自定义的C++析构方法!isa.has_cxx_dtor,没有用到sideTable来做引用计数 !isa.has_sidetable_rc
    3. 其余的,则进入object_dispose((id)this)慢释放分支。

    如果obj被weak引用了,应该进入object_dispose((id)this)分支:

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

    object_dispose方法中,会先调用objc_destructInstance(obj)来析构obj,再用 free(obj)来释放内存。

    objc_destructInstance的实现如下:

    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); // 调用C++析构函数
            if (assoc) _object_remove_assocations(obj); // 移除所有的关联对象,并将其自身从Association Manager的map中移除
            obj->clearDeallocating(); // 清理相关的引用
        }
        return obj;
    }
    

    objc_destructInstance 中,会清理相关的引用:obj->clearDeallocating()

    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());
    }
    

    clearDeallocating中有两个分支,先判断obj是否采用了优化isa引用计数。没有,则要清理obj存储在sideTable中的引用计数等信息,这个分支在当前64位设备中应该不会进入,不必关系。
    如果启用了isa优化,则判断是否使用了sideTable,使用的原因是因为做了weak引用(isa.weakly_referenced ) 或 使用了sideTable的辅助引用计数(isa.has_sidetable_rc)。符合这两种情况之一,则进入慢析构路径:

       // Slow path for non-pointer isa with weak refs and/or side table data.
            clearDeallocating_slow();
    
    NEVER_INLINE void
    objc_object::clearDeallocating_slow()
    {
        assert(isa.nonpointer  &&  (isa.weakly_referenced || isa.has_sidetable_rc));
    
        SideTable& table = SideTables()[this]; // 在全局的SideTables中,以this指针为key,找到对应的SideTable
        table.lock();
        if (isa.weakly_referenced) { // 如果obj被弱引用
            weak_clear_no_lock(&table.weak_table, (id)this); // 在SideTable的weak_table中对this进行清理工作
        }
        if (isa.has_sidetable_rc) { // 如果采用了SideTable做引用计数
            table.refcnts.erase(this); // 在SideTable的引用计数中移除this
        }
        table.unlock();
    }
    

    这里调用了weak_clear_no_lock来做weak_table的清理工作,同时将所有weak引用该对象的ptr置为nil

    void 
    weak_clear_no_lock(weak_table_t *weak_table, id referent_id) 
    {
        objc_object *referent = (objc_object *)referent_id;
    
        weak_entry_t *entry = weak_entry_for_referent(weak_table, referent); // 找到referent在weak_table中对应的weak_entry_t
        if (entry == nil) {
            /// XXX shouldn't happen, but does with mismatched CF/objc
            //printf("XXX no entry for clear deallocating %p\n", referent);
            return;
        }
    
        // zero out references
        weak_referrer_t *referrers;
        size_t count;
        
        // 找出weak引用referent的weak 指针地址数组以及数组长度
        if (entry->out_of_line()) {
            referrers = entry->referrers;
            count = TABLE_SIZE(entry);
        } 
        else {
            referrers = entry->inline_referrers;
            count = WEAK_INLINE_COUNT;
        }
        
        for (size_t i = 0; i < count; ++i) {
            objc_object **referrer = referrers[i]; // 取出每个weak ptr的地址
            if (referrer) {
                if (*referrer == referent) { // 如果weak ptr确实weak引用了referent,则将weak ptr设置为nil,这也就是为什么weak 指针会自动设置为nil的原因
                    *referrer = nil;
                }
                else if (*referrer) { // 如果所存储的weak ptr没有weak 引用referent,这可能是由于runtime代码的逻辑错误引起的,报错
                    _objc_inform("__weak variable at %p holds %p instead of %p. "
                                 "This is probably incorrect use of "
                                 "objc_storeWeak() and objc_loadWeak(). "
                                 "Break on objc_weak_error to debug.\n", 
                                 referrer, (void*)*referrer, (void*)referent);
                    objc_weak_error();
                }
            }
        }
        
        weak_entry_remove(weak_table, entry); // 由于referent要被释放了,因此referent的weak_entry_t也要移除出weak_table
    }
    

    OK,上面就是为什么当对象析构时,所有弱引用该对象的指针都会被设置为nil的原因。

    总结

    纵观weak引用的底层实现,其实原理很简单。就是将所有弱引用obj的指针地址都保存在obj对应的weak_entry_t中。当obj要析构时,会遍历weak_entry_t中保存的弱引用指针地址,并将弱引用指针指向nil,同时,将weak_entry_t移除出weak_table。

    这里涉及到runtime 四个重要的数据结构:
    SideTablesSideTableweak_tableweak_entry_t.

    关于它们,我们在Objective-C runtime机制(5)——iOS 内存管理中已有涉及。

    为了加深对runtime的理解,在接下来的一章中,我们会依次分析这四个数据结构。

    补充

    在文章的开头,我们举的例子:

    int main(int argc, char * argv[]) {
        @autoreleasepool {
            NSObject *obj = [[NSObject alloc] init];
            __weak NSObject *weakObj = obj;
        }
    }
    

    它底层会调用objc_initWeak方法,并最终会调用

    storeWeak<DontHaveOld, DoHaveNew, DoCrashIfDeallocating>
            (location, (objc_object*)newObj);
    

    这是,传入storeWeak的参数中,haveOld被设置为false,表明weakObj之前并没有weak指向其他的对象。

    那么,什么时候storeWeak的参数haveOld被设置为true呢?当我们的weakObj已经指向一个weak对象,又要指向新的weak对象时,storeWeak的haveOld参数会被置为true:

    int main(int argc, char * argv[]) {
        @autoreleasepool {
            NSObject *obj = [[NSObject alloc] init];
            __weak NSObject *weakObj = obj; // 这里会调用objc_initWeak方法,storeWeak的haveOld == false
            NSObject *obj2 = [[NSObject alloc] init];
            weakObj = obj2;  // 这里会调用objc_storeWeak方法,storeWeak的haveOld == true,会将之前的引用先移除
        }
    }
    

    objc_storeWeak方法的实现如下:

    /** 
     * This function stores a new value into a __weak variable. It would
     * be used anywhere a __weak variable is the target of an assignment.
     * 
     * @param location The address of the weak pointer itself
     * @param newObj The new object this weak ptr should now point to
     * 
     * @return \e newObj
     */
    id
    objc_storeWeak(id *location, id newObj)
    {
        return storeWeak<DoHaveOld, DoHaveNew, DoCrashIfDeallocating>
            (location, (objc_object *)newObj);
    }
    
    展开全文
  • 同时还留了一个小尾巴,就是Mach-O文件中和Objective-C以及runtime相关的Segment section。今天,就来了解一下它们。 OC之源起 我们知道,程序的入口点在iOS中被称之为main函数: #import &amp;amp;amp...
  • 上一篇文章,我们学习了runtime的消息发送和消息转发机制(查看链接: runtime从入门到精通(五)—— 消息发送和消息转发 ),倒到此为止,有关runtime的理论知识介绍就先告于段落,小伙伴们,真正的干货来了,...
  • iOS面试中经常问的点 - RunTime

    千次阅读 2018-05-09 16:47:36
    RunTime简介RunTime简称运行时。OC就是运行时机制,也就是在运行时候的一些机制,其中最主要的是消息机制。对于C语言,函数的调用在编译的时候会决定调用哪个函数,如果调用未实现的函数就会报错。对于OC语言,属于...
  • ios RunTime机制详解

    千次阅读 2018-06-02 20:34:04
    一:基本概念Runtime基本是用C和汇编写的,可见苹果为了动态系统的高效而作出的努力。你可以在这里下到苹果维护的开源代码。苹果和GNU各自维护一个开源的runtime版本,这两个版本之间都在努力的保持一致。Objective-...
  • RunTime类详解

    千次阅读 2018-03-06 22:24:05
    一个RunTime就代表一个运行环境。2.RunTime类常用的方法:(1) getRuntime():该方法用于返回当前应用程序的运行环境对象。(2) exec(String command):该方法用于根据指定的路径执行对应的可执行文件。①实例:...
  • runtime介绍及基本使用

    千次阅读 2018-04-15 11:56:17
    1. 概念 runtime(运行时系统),是一套基于C语言API,包含在 &lt;objc/runtime.h&gt;和&lt;objc/message.h&gt;中,运行时系统的功能是在运行期间(而不是编译期或其他时机)通过代码去动态的操作类...
  • 提示api-ms-win-crt-runtime-l1-1-0.dll 丢失,安装这个小玩意就可以解决了
  • Window丢失api-ms-win-crt-runtime-l1-1-0.dll

    万次阅读 热门讨论 2018-05-11 16:09:59
    api-ms-win-crt-runtime-l1-1-0.dll 丢失 二、解决 http://download.csdn.net/download/su749520/10190779 http://www.greenxf.com/soft/125654.html 把api-ms-win-crt-runtime-l1-1-0.dll下载到电脑 直接...
  • 1、进入C:\Windows\SysWOW64,找到api-ms-win-crt-runtime-l1-1-0.dll文件,将其删除。 2、下载vc-redist.x64: 链接: https://pan.baidu.com/s/1gAyDnvIv1WUf1dF2cKTOGg 提取码: 5usr 3、安装后重启电脑,问题解决!...
  • iOS运行时Runtime浅析

    万次阅读 2016-07-17 21:43:49
    运行时是iOS中一个很重要的概念,iOS运行过程中都会被转化为runtime的C代码执行。例如[target doSomething];会被转化成objc)msgSend(target,@selector(doSomething))来执行。这篇博客会较为全面的来讲解下Runtime。...
  • 打开浏览器时,出现Microsoft Visual C++ Runtime Library Runtime Error错误,初步估计是软件冲突,可能有多种出错的方式,我的是浏览器自动关闭。 一、
  • iOS Runtime 详解

    千次阅读 2017-05-04 17:06:20
    什么是runtime依照苹果文档的说法,runtime是: The Objective-C language defers as many decisions as it can from compile time and link time to runtime. (尽量将决定放到运行的时候,而不是在编译和链接...
  • 解决办法:Failed to load the native TensorFlow runtime.

    万次阅读 多人点赞 2020-07-23 17:54:30
    跑CPU版的object-detection的示例程序,导入tensorflow时...Failed to load the native TensorFlow runtime. 解决办法就是:pip install --upgrade --ignore-installed tensorflow 更新一下tensorflow就好了 ...
  • Java中Runtime

    千次阅读 2018-04-02 16:07:36
    转载自:https://www.cnblogs.com/lixiaolun/p/4320754.html一、概述 Runtime类封装了运行时的... 一般不能实例化一个Runtime对象,应用程序也不能创建自己的 Runtime 类实例,但可以通过 getRuntime 方法获取当前...
  • Linux电源管理-Runtime PM

    千次阅读 2016-11-10 11:05:54
    1. 什么是Runtime PM?  Runtime PM (Runtime Power Management)翻译过来就是运行时电源管理。主要的作用是: 每个设备处理好自己的电源管理,在不需要工作时进入低功耗状态。也就是"各人自扫门前雪"。 2. 为什么...
  • android runtime 创建流程

    千次阅读 2017-11-12 21:53:00
    在zygote进程启动过程中会创建art虚拟机,那我们就看一下art虚拟机是怎么创建出来的。 用户空间的init进程起来之后,会根据.xxxrc 文件中的配置,把相关进程运行起来,通过fork()和execve()来创建和加载对应的进程...
1 2 3 4 5 ... 20
收藏数 725,458
精华内容 290,183
关键字:

runtime