Swift Runtime - 类和对象

时间  2019-11-08
标签 swift runtime 对象 栏目 Swift 繁體版
原文   原文链接

编译阶段

class PureSwiftClass {
    private var private_var_property = 0
    @objc private var objc_private_var_property = 0
    var instance_property = 0
    @objc let objc_instance_let_property = 0
    @objc var objc_instance_var_property = 0

    func instance_method() {}
    @objc func objc_instance_method() {}
    @objc dynamic func objc_dynamic_instance_method() {}
}
复制代码

下面是编译阶段生成的类信息：swift

_$s10TestObjectSwiftClassCN:
struct __objc_class {
    _OBJC_METACLASS_$__TtC10TestObjectSwiftClass, // metaclass
    _OBJC_CLASS_$_SwiftObject, // superclass
    __objc_empty_cache, // cache
    0x0, // vtable
    __objc_class__TtC10TestObjectSwiftClass_data+1 // data
}

__objc_class__ObjectSwiftClass_data:
struct __objc_data {
    0x80, // flags
    8,// instance start
    48,                                  // instance size
    0x0,
    0x0,                                 // ivar layout
    "ObjectSwiftClass",                     // name
    __objc_class__TtC10TestObjectSwiftClass_methods, // base methods
    0x0,                                 // base protocols
    __objc_class__TtC10Test6ObjectSwiftClass_ivars, // ivars
    0x0,                                 // weak ivar layout
    __objc_class__TtC10TestObjectSwiftClass_properties // base properties
}

// methods
__objc_class__ObjectSwiftClass_methods:
struct __objc_method_list { 
    0x18,                                // flags
    8                                    // method count
}

struct __objc_method {                                 
    "objc_private_instance_var_property",                     // name
    "q16@0:8",                              // signature
    -[_TtC10TestObjectSwiftClass objc_private_instance_var_property] // implementation
}
struct __objc_method {                                 
    "setObjc_private_var_property:",                     // name
}
struct __objc_method {
    "objc_instance_var_property",                     // name
}
struct __objc_method {
    "setObjc_instance_var_property:",                     // name
}
struct __objc_method {                                 
    "objc_instance_let_property",                     // name
}
struct __objc_method {                                 
    "objc_instance_method",                     // name
}
struct __objc_method {                                 
    "objc_dynamic_instance_method",                     // name
}
struct __objc_method {                                
    "init",                               // name
}

// ivars
__objc_class__TtC10TestObjectSwiftClass_ivars:
struct __objc_ivars {                               
    32,                                  // entsize
    5                                    // count
}
struct __objc_ivar {                                   
    "private_var_property",                     // name
}
struct __objc_ivar {                                   
    "objc_private_var_property",           // name
}
struct __objc_ivar {                                   
    "instance_var_property",                     // name
}
struct __objc_ivar {                                   
    "objc_instance_var_property",           // name
}
struct __objc_ivar {                                   
    "objc_instance_let_property",           // name
}
复制代码

根据上面编译器生成的数据，能够获得一些信息：缓存

class

  • Swift类编译阶段会生成与Objective-C同样的类元数据，这也是为何Swift和Objective-C能够互相调用。

泛型类不会生成类元数据__objc_class结构，不过会生成roData。bash

  • class若是没有显式继承某个类，都被隐式继承SwiftObject。

属性

  • 全部属性都会添加到class_ro_t中的ivars结构中，包括private属性。
  • 使用@objc修饰的属性，var属性会添加set/get方法，let属性只会添加get方法。

Swift类的 属性能够经过 objc-runtime进行修改和获取。ide

方法

  • 使用@objc修饰的方法会添加到ro_class_t的methods结构中。

Swift结构

ClassMetadata

ClassMetadata是Swift中全部类元数据格式。优化

struct objc_object {
    Class isa;
}
struct objc_class: objc_object {
    Class superclass;
    cache_t cache;           
    class_data_bits_t bits;
}
struct swift_class_t: objc_class {
    uint32_t flags;//类标示
    uint32_t instanceAddressOffset;
    uint32_t instanceSize;//对象实例大小
    uint16_t instanceAlignMask;//
    uint16_t reserved;// 保留字段
    uint32_t classSize;// 类对象的大小
    uint32_t classAddressOffset;// 
    void *description;//类描述
};
复制代码

Swift和Objective-C的类元数据是共用的，Swift类元数据只是Objective-C的基础上增长了一些字段。ui

源代码中也有一些地方直接使用 reinterpret_cast进行相互转换。this

Class objcClass = [objcObject class];
ClassMetadata *classAsMetadata = reinterpret_cast<const ClassMetadata *>(objcClass);
复制代码

HeapObject

在Swift中，一个class对象实际上就是一个HeapObject结构体指针。HeapObject由HeapMetadata和InlineRefCounts组成，HeapMetadata是类对象元数据的指针，InlineRefCounts用于管理引用计数。spa

struct HeapObject {
  HeapMetadata const *metadata;
  InlineRefCounts refCounts;
};
复制代码
  • HeapMetadata和Objective-C中的isa_t结构同样，使用ISA_MASK获取到类对象。
@interface ObjcClass: NSObject {
}

ObjcClass *objcObject = [ObjcClass new];
HeapObject *heapObject = static_cast<HeapObject *>(objcObject);
ObjcClass *objcObject2 =  static_cast<ObjcClass *>(heapObject);

[heapObject retain];
复制代码

不过由于 Objective-C和Swift引用计数管理方式不同，因此转换之后依然要使用以前的方式进行引用计数管理。设计

Objective-C和Swift对象结构：指针

Objc对象结构 {
    isa_t,
    实例变量
}
Swift对象结构 {
    metadata,
    refCounts, 
    实例变量
}
复制代码

建立对象

swift_allocObject
  • swift_allocObject方法用于建立一个Swift对象。
void *swift::swift_slowAlloc(size_t size, size_t alignMask) {
  void *p;
  // This check also forces "default" alignment to use AlignedAlloc.
  if (alignMask <= MALLOC_ALIGN_MASK) {
    p = malloc(size);
  } else {
    size_t alignment = (alignMask == ~(size_t(0)))
                           ? _swift_MinAllocationAlignment
                           : alignMask + 1;
    p = AlignedAlloc(size, alignment);
  }
  if (!p) swift::crash("Could not allocate memory.");
  return p;
}
static HeapObject *_swift_allocObject_(HeapMetadata const *metadata,
                                       size_t requiredSize,
                                       size_t requiredAlignmentMask) {
  auto object = reinterpret_cast<HeapObject *>(
      swift_slowAlloc(requiredSize, requiredAlignmentMask));
  // NOTE: this relies on the C++17 guaranteed semantics of no null-pointer
  // check on the placement new allocator which we have observed on Windows,
  // Linux, and macOS.
  new (object) HeapObject(metadata);//建立一个新对象，
  return object;
}
复制代码
  • 根据对象大小作字节对齐处理，以后调用malloc分配内存，以后会初始化实例变量。
  • metadata表示类对象元数据。
  • requiredSize和requiredAlignmentMask表示对象大小和字节对齐方式。
swift_initStackObject
  • 在某些场景对象建立会被编译器优化为swift_initStackObject方法。swift_initStackObject在栈上建立一个对象。没有引用计数消耗，也不用malloc内存。
HeapObject *
swift::swift_initStackObject(HeapMetadata const *metadata,
                             HeapObject *object) {
  object->metadata = metadata;
  object->refCounts.initForNotFreeing();
  return object;
}
复制代码

销毁对象

swift_deallocClassInstance
  • swift_deallocClassInstance用于销毁对象，在对象dealloc时调用。
void swift::swift_deallocClassInstance(HeapObject *object,
                                       size_t allocatedSize,
                                       size_t allocatedAlignMask) {
#if SWIFT_OBJC_INTEROP
  objc_destructInstance((id)object);
#endif
  swift_deallocObject(object, allocatedSize, allocatedAlignMask);//
}
复制代码
  • 调用objc_destructInstance方法释放关联对象和弱引用释放处理。

Objc runtime的对象弱引用，不是Swift环境的弱引用。

  • 调用swift_deallocObject方法调用free回收内存。

引用计数相关方法

  • swift_retain和objc的实现相似，对引用计数进行+1，溢出时将一部分引用计数值保存到sideTable中。
  • swift_release对引用计数进行-1，当引用计数为0时，调用销毁对象方法。
  • swift_weak相关的方法用于管理weak弱引用。

SwiftObject

在Swift中，一个class若是没有显式继承其余的类，都被隐式继承SwiftObject。SwiftObject实现了NSObject协议的全部方法和一部分NSObject类的方法。主要是重写了一部分方法，将方法实现改成Swift相关方法。

@interface SwiftObject<NSObject> {
 @private
  Class isa;
  InlineRefCounts refCounts;
}
@end
复制代码

没有实现 resolveInstanceMethod，forwardingTargetForSelector等方法，这些方法能够在找不到特定方法时能够进行动态处理，应该是不想提供纯 Swift类在这块的能力。

好比retain，release方法改成了使用swift runtime进行引用计数管理:

- (id)retain {
  auto SELF = reinterpret_cast<HeapObject *>(self);
  swift_retain(SELF);
  return self;
}
- (void)release {
  auto SELF = reinterpret_cast<HeapObject *>(self);
  swift_release(SELF);
}
复制代码

由于纯 Swift类不能直接与Objective-C交互，那么SwiftObject这样设计的目的是什么？

下面是两种使用场景：

  • 就是将纯Swift类做为id参数传递到Objective-C方法中使用。
- (void)test:(id)object {
  [object retain];
  [object performSelector:@selector(objc_instance_method)];
}
复制代码
let object = NSObject()
test(object)
复制代码
  • 使用消息发送的方式调用方法。
class SwiftClass {
    @objc dynamic func objc_dynamic_instance_method() {}
}
let object = SwiftClass()
object.objc_dynamic_instance_method()
复制代码

不过以上场景应该是不多使用的，不清楚还有没有其它目的。并且这样设计的话，纯Swift类也应该能够被Objective-C直接使用。

初始化对象

Objective-C

Objective-C使用Swift-NSObject子类

class SwiftClass: NSObject {
}
复制代码
SwiftClass *object = [[SwiftClass alloc] init];
复制代码
  • 由于二进制文件中Swift类包含了和Objective-C同样的类数据信息，因此能够直接使用Objective-C的方式建立。

Swift

Swift类

建立一个纯Swift类对象。

class SwiftClass {
}
SwiftClass()
复制代码
swift_getInitializedObjCClass
Class swift::swift_getInitializedObjCClass(Class c) {
  [c self];// 为了确保objc-runtime realize class
  return c;
}
复制代码
Class objcClass = swift_getInitializedObjCClass(SwiftClass);
HeapObject *object = swift_allocObject(objcClass);
// 释放
swift_release(object);
复制代码

原生Objective-C类

建立一个原生Objective-C类对象。

@interface ObjectClass
@end
复制代码
ObjectClass()
复制代码
Class objcClass = swift_getInitializedObjCClass(ObjectClass);
Metadata *metadata = swift_getObjCClassMetadata(objcClass);
ClassMetadata *classMetadata = swift_getObjCClassFromMetadata(metadata);
ObjectClass *object = [classMetadata allocWithZone] init];
// 释放
objc_release(object);
复制代码

swift_getObjCClassMetadata和swift_getObjCClassFromMetadata有什么做用？

Swift-NSObject子类

建立一个Swift-NSObject子类对象。

class SwiftClass: NSObject {
}
SwiftClass()
复制代码
Class objcClass = swift_getInitializedObjCClass(SwiftClass);
HeapObject *object = objc_allocWithZone(objcClass);
// 释放
objc_release(object);
复制代码

Swift泛型类

建立一个Swift泛型类对象。

class GenericClass<T> {
}
GenericClass<Int>()
复制代码
MetadataResponse response = swift_getGenericMetadata();
ClassMetadata *classMetadata = swift_allocateGenericClassMetadata();
swift_initClassMetadata2(classMetadata);
HeapObject *object = swift_allocObject(objcClass);
复制代码
  • 根据泛型类型做为参数，调用swift_getGenericMetadata方法获取类对象缓存。存在缓存直接返回，没有缓存，调用swift_allocateGenericClassMetadata方法。

每个不一样的泛型类型都会建立一个新的ClassMetadata，以后保存到缓存中复用。

swift_allocateGenericClassMetadata：

  • 建立一个新的ClassMetadata结构。
  • 初始化objc_class和swift_class_t相关的属性, 同时设置isa和roData。

swift_initClassMetadataImpl：

  • 设置Superclass，若是没有指明父类，会被设置为SwiftObject。
  • 初始化Vtable。
  • 设置class_ro_t的InstanceStart和InstanceSize字段，遍历ivars修改每一个ivar的offset。
  • 将该类注册到objc runtime。
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程