这个栏目将持续更新--请iOS的小伙伴关注!
（答案不唯一，仅供参考，文章最后有福利）
大厂iOS面试题+答案篇
runtime相关问题之内存部分的关联属性或者hook相关的Method Swizzle
经过前两期内容 我们这期来讲一下 内存部分的剩余问题 主要包含如下:
Method Swizzle注意事项- 属性修饰符atomic的内部实现是怎么样的?能保证线程安全吗
- iOS 中内省的几个方法有哪些？内部实现原理是什么
class、objc_getClass、object_getclass方法有什么区别?
Method Swizzle注意事项
- 需要注意的是交换方法实现后的副作用,
method_exchangeImplementations().交换方法函数最终会以objc_msgSend()方式调用,副作用主要集中在第一个参数 如下示例
1. objc_msgSend(payment, @selector(quantity))
方法交换后再去调用quantity方法将有可能会crash.解决这种副作用的方式是使用method_setImplementation()来替换原来的交换方式,这样才最为合理, 具体原理请参照 Objc 黑科技 - Method Swizzle 的一些注意事项
-
避免交换父类方法
如果当前类没有实现被交换的方法且父类实现了,此时父类的实现会被交换,若此父类的多个继承者都在交换时会引起多次交换导致混乱,同时调用父类方法有可能因为找不到方法签名而crash.
所以交换前都应该check能否为当前类添加被交换的函数的新的实现IMP,这个过程大概分为3步骤class_addMethodcheck能否添加方法
1. BOOL class_addMethod(Class cls, SEL name, IMP imp, const char *types)
2.
给类cls的SEL添加一个实现IMP, 返回YES则表明类cls并未实现此方法，返回NO则表明类已实现了此方法。注意：添加成功与否，完全由该类本身来决定，与父类有无该方法无关。
class_replaceMethod替换类cls的SEL的函数实现为imp
1. class_replaceMethod(Class _Nullable cls, SEL _Nonnull name, IMP _Nonnull imp,
2. const char * _Nullable types)
3.
method_exchangeImplementations最终方法交换
1. method_exchangeImplementations(Method _Nonnull m1, Method _Nonnull m2)
2.
- 交换方法应在+load方法
这个前面讲消息转发的时候讲过,+load不是消息转发的方式实现的且在运行时初始化过程中类被加载的时候调用,而且父类,当前类,category,子类等 都会调用一次.所以这里最适合写方法交换的hook(Method Swizzle).
-
交换的分类方法应该添加自定义前缀,避免冲突
这个毫无疑问,方法名称一样的时候会出现,分类的方法会覆盖类中同名的方法.
属性修饰符atomic的内部实现是怎么样的?能保证线程安全吗?
atomic内部实现
1. id objc_getProperty(id self, SEL _cmd, ptrdiff_t offset, BOOL atomic) {
2. ...
3. id *slot = (id*) ((char*)self + offset);
4. if (!atomic) return *slot;
5. // Atomic retain release world
6. spinlock_t& slotlock = PropertyLocks[slot];
7. slotlock.lock();
8. id value = objc_retain(*slot);
9. slotlock.unlock();
10. return objc_autoreleaseReturnValue(value);
11. }
1. static inline void reallySetProperty(id self, SEL _cmd, id newValue, ptrdiff_t offset, bool atomic, bool copy, bool mutableCopy)
2. {
3. ...
4. if (!atomic) {
5. oldValue = *slot;
6. *slot = newValue;
7. } else {
8. spinlock_t& slotlock = PropertyLocks[slot];
9. slotlock.lock();
10. oldValue = *slot;
11. *slot = newValue;
12. slotlock.unlock();
13. }
14. objc_release(oldValue);
15. }
property 的 atomic 是采用 spinlock_t自旋锁实现的.
能保证线程安全吗?
atomic通过这种方法.在运行时仅仅是保证了set,get方法的原子性.所以使用atomic并不能保证线程安全。
iOS 中内省的几个方法有哪些？内部实现原理是什么?
首先要明白一个名词 introspection 反省,内省的意思,在iOS开发中我们会称它为反射.
内省方法 例如常用的NSObject中的isKindOfClass: 通过实例对象判断class这就是一种内省方法或者叫反射方法,但我认为NSClassFromString()这个应该也算一种反射方法.
iOS 中内省的几个方法
我们从NSObject.h中看下吧
1. - (BOOL)isKindOfClass:(Class)aClass; //判断是否是这个类或者这个类的子类的实例
2. - (BOOL)isMemberOfClass:(Class)aClass; //判断是否是这个类的实例
3. - (BOOL)conformsToProtocol:(Protocol *)aProtocol; //判断是否遵守某个协议
4. + (BOOL)conformsToProtocol:(Protocol *)protocol; //判断某个类是否遵守某个协议
5. - (BOOL)respondsToSelector:(SEL)aSelector; //判读实例是否有这样方法
6. + (BOOL)instancesRespondToSelector:(SEL)aSelector; //判断类是否有这个方法
7. ...
内部实现原理
1.isKindOfClass:
1. + (BOOL)isKindOfClass:(Class)cls {
2. for (Class tcls = self->ISA(); tcls; tcls = tcls->superclass) {
3. if (tcls == cls) return YES;
4. }
5. return NO;
6. }
7.
8. - (BOOL)isKindOfClass:(Class)cls {
9. for (Class tcls = [self class]; tcls; tcls = tcls->superclass) {
10. if (tcls == cls) return YES;
11. }
12. return NO;
13. }
类方法是通过ISA()函数拿到指向元类的存储isa指针数据的地址bit位按位与上相关掩码的方式判断当前是否是某个类的子类.
实例方法是通过objc_object::getIsa()函数通过存储的tag_ext表形式拿到isa对于的class来取出class平check来实现的.
2.isMemberOfClass:
1. + (BOOL)isMemberOfClass:(Class)cls {
2. return self->ISA() == cls;
3. }
4.
5. - (BOOL)isMemberOfClass:(Class)cls {
6. return [self class] == cls;
7. }
这俩方法非常简单直接 拿到isa指针对比
3.conformsToProtocol:
1. + (BOOL)conformsToProtocol:(Protocol *)protocol {
2. if (!protocol) return NO;
3. for (Class tcls = self; tcls; tcls = tcls->superclass) {
4. if (class_conformsToProtocol(tcls, protocol)) return YES;
5. }
6. return NO;
7. }
8.
9. - (BOOL)conformsToProtocol:(Protocol *)protocol {
10. if (!protocol) return NO;
11. for (Class tcls = [self class]; tcls; tcls = tcls->superclass) {
12. if (class_conformsToProtocol(tcls, protocol)) return YES;
13. }
14. return NO;
15. }
两个方法最终还是去isa->data()->protocols 拿到相关协议然后判断是否存在相关协议 如下代码：
1. BOOL class_conformsToProtocol(Class cls, Protocol *proto_gen)
2. {
3. protocol_t *proto = newprotocol(proto_gen);
4. if (!cls) return NO;
5. if (!proto_gen) return NO;
6. mutex_locker_t lock(runtimeLock);
7. checkIsKnownClass(cls);
8. ASSERT(cls->isRealized())
9. for (const auto& proto_ref : cls->data()->protocols) {
10. protocol_t *p = remapProtocol(proto_ref);
11. if (p == proto || protocol_conformsToProtocol_nolock(p, proto)) {
12. return YES;
13. }
14. }
15. return NO;
16. }
这里可以清晰的看到for循环 取出相关protocol指针 然后通过指针和传入的参数生成的
proto对比 4.respondsToSelector:
1. + (BOOL)respondsToSelector:(SEL)sel {
2. return class_respondsToSelector_inst(self, sel, self->ISA());
3. }
4.
5. - (BOOL)respondsToSelector:(SEL)sel {
6. return class_respondsToSelector_inst(self, sel, [self class]);
7. }
这个源码比较麻烦 我简单叙述一下吧 实际上调用栈比较深就是一直寻找到当前实例能响应哪些方法,当前类没有就去父类,父类没有则直到元类.
1. respondsToSelector:
2. |__ class_respondsToSelector_inst()
3. |__ lookUpImpOrNil()
4. |__ lookUpImpOrForward()
5. 返回IMP结果
这就是整个消息转发的过程 就不在这里赘述了.感兴趣回看一下第二章 消息转发部分
我上述列举了一些常用的内省方法,其它的都方法基本没什么特别之处都是拿到isa各种操作内部的获取相关属性的函数返回结.
class、objc_getClass、object_getclass 方法有什么区别?
我用xcode随便建了一个demo 打印一下viewcontrooller的内容
1. @implementation ViewController
2.
3. - (void)viewDidLoad {
4. [super viewDidLoad];
5.
6. Class cls1 = [self class];
7. Class cls2 = object_getClass(cls1);
8. Class cls3 = objc_getClass(object_getClassName([self class]));
9. NSLog(@"%p",cls1);
10. NSLog(@"%p",cls2);
11. NSLog(@"%p",cls3);
12. }
13. @end
输出
1. 2020-08-31 16:15:48.150285+0800 ClassDemo[5582:55836] 0x10205b3b0
2. 2020-08-31 16:15:48.150456+0800 ClassDemo[5582:55836] 0x10205b3d8
3. 2020-08-31 16:15:48.150575+0800 ClassDemo[5582:55836] 0x10205b3b0
我简单列举了一张表格
原因：因为class返回的是self，而object_getClass返回的是isa指向的对象
总结
以上就是"一套高效的iOS面试题之runtime相关问题"中的内存剩余部分,问题答案虽然简短 但是每道题都问的非常到位,值得一看！
更多：
