3-1 runtime-isa数据结构
2019-03-28 本文已影响0人
Rumbles
IMP:一个函数指针,保存了方法的地址 一张SEL和IMP的对应表 通过SEL可以找到IMP
runtime 运行时
OC是一门动态语言，与C++这种静态语言不同，静态语言的各种数据结构在编译期已经决定了，不能够被修改。而动态语言却可以使我们在程序运行期，动态的修改一个类的结构，如修改方法实现，绑定实例变量等。
NSObject 类 的数据结构。
以前的isa指针就是保存的指针。64位之后还保存了其他的信息 内存管理方面的
@interface NSObject <NSObject> {
Class isa ;
}
typedef struct objc_class *Class;
--> 唯一的成员变量 objc_class类型的 isa
我们在xcode中看到的数据结构
struct objc_class {
Class _Nonnull isa OBJC_ISA_AVAILABILITY;
#if !__OBJC2__
Class _Nullable super_class OBJC2_UNAVAILABLE;
const char * _Nonnull name OBJC2_UNAVAILABLE;
long version OBJC2_UNAVAILABLE;
long info OBJC2_UNAVAILABLE;
long instance_size OBJC2_UNAVAILABLE;
struct objc_ivar_list * _Nullable ivars OBJC2_UNAVAILABLE;
struct objc_method_list * _Nullable * _Nullable methodLists OBJC2_UNAVAILABLE;
struct objc_cache * _Nonnull cache OBJC2_UNAVAILABLE;
struct objc_protocol_list * _Nullable protocols OBJC2_UNAVAILABLE;
#endif
} OBJC2_UNAVAILABLE;
但是已经在OC 2.0中，这种关于objc_class的定义已经废弃掉了 最新的是下面的
objc_class 结构体 类 objc_class objc_object
runtime 源码
struct objc_class : objc_object {
// Class ISA;
Class superclass; 父类
cache_t cache; 方法缓存
class_data_bits_t bits; 用于获取类的信息
class_rw_t *data() { ///>. 获取到的是 bits里面的信息
return bits.data();
}
void setData(class_rw_t *newData) {
bits.setData(newData);
}
// 省略其他方法
。。。
}
cache_t cache 方法缓存
1.用于快速查找方法执行函数
2.是可增量扩展的哈希表【提高查找效率】
3.局部性原理的应用[]
struct cache_t {
struct bucket_t *_buckets;
mask_t _mask;
mask_t _occupied;
// 省略其余方法
。。。
}
typedef uintptr_t cache_key_t;
struct bucket_t {
private:
cache_key_t _key;
IMP _imp;
public:
inline cache_key_t key() const { return _key; }
inline IMP imp() const { return (IMP)_imp; }
inline void setKey(cache_key_t newKey) { _key = newKey; }
inline void setImp(IMP newImp) { _imp = newImp; }
void set(cache_key_t newKey, IMP newImp);
};
runtime方法调用的流程是，当要调用一个方法时，先不去Class的方法列表中查找，而是先去找cache_t cache 。当系统调用过一个方法后，会将其实现IMP和key存放到cache中，因为理论上一个方法调用过后，被再次调用的概率很大。
class_data_bits_t bits 获取类的基本信息
struct class_data_bits_t {
// Values are the FAST_ flags above.
uintptr_t bits;
public:
class_rw_t* data() { ///获取类信息的主要数据结构
return (class_rw_t *)(bits & FAST_DATA_MASK);
}
void setData(class_rw_t *newData) ///> 主要
{
assert(!data() || (newData->flags & (RW_REALIZING | RW_FUTURE)));
// Set during realization or construction only. No locking needed.
// Use a store-release fence because there may be concurrent
// readers of data and data's contents.
uintptr_t newBits = (bits & ~FAST_DATA_MASK) | (uintptr_t)newData;
atomic_thread_fence(memory_order_release);
bits = newBits;
}
---------------------
struct class_rw_t {
// Be warned that Symbolication knows the layout of this structure.
uint32_t flags;
uint32_t version;
const class_ro_t *ro; ///> 只读
method_array_t methods; //方法列表
property_array_t properties; //属性列表
protocol_array_t protocols; //协议列表
Class firstSubclass;
Class nextSiblingClass;
char *demangledName;
};
---------------------
struct class_ro_t {
uint32_t flags;
uint32_t instanceStart;
uint32_t instanceSize;
#ifdef __LP64__
uint32_t reserved;
#endif
const uint8_t * ivarLayout;
const char * name; //类名
method_list_t * baseMethodList;
protocol_list_t * baseProtocols;
const ivar_list_t * ivars; //成员变量列表
const uint8_t * weakIvarLayout;
property_list_t *baseProperties;
method_list_t *baseMethods() const {
return baseMethodList;
}
};
class_rw_t中的方法列表，属性列表，协议列表等包含的是该类本身加上分类的所有的方法，属性，协议，因此是可变的，即可写
它里面包含_class_ro_t中存放的是类初始化时本身的方法，协议，成员变量等，是不包括分类的只读
这是Class的核心，
method_t
struct method_t {
SEL name; // 函数名
const char *types; // 编码（返回值类型，参数类型）
IMP imp; // 指向函数的指针（函数地址）
};
types 如何表达返回值和参数的呢？
-(void)aMethod; 参考 Type Encoding
v@：
realizeClass 一个runtime对象方法
objc_class的一个方法 在objc_class的data()方法最初返回的是const class_ro_t * 类型，也就是类的基本信息。因为在调用realizeClass方法前，Category定义的各种方法，属性还没有附加到class上，因此只能够返回类的基本信息。而当我们调用realizeClass时，会在函数内部将Category中定义的各种扩展附加到class上，同时改写data()的返回值为class_rw_t *类
objc_object. 对象
typedef struct objc_object *id;
id = objc_object
struct objc_object {
private:
isa_t isa;
public:
// ISA() assumes this is NOT a tagged pointer object
Class ISA();
// getIsa() allows this to be a tagged pointer object
Class getIsa();
// 省略其余方法
...
}
OC的底层实现是runtime，在runtime这一层，对象被定义为objc_object 结构体，类被定义为了objc_class 结构体。而objc_class 继承于objc_object， 因此，类可以看做是一类特殊的对象
共用体isa_t. 共用体是使用同一段内存空间
isa 相关操作：
通过。objc_object isa 指针 获取他的类对象。
类对象 的isa指针获取元类对象
类也是一个对象。就叫类对象
弱引用的相关方法：
标记一个对象是否有弱引用
关联对象相关：
内存管理相关：retain release
isa指针
objc_object 的 isa指针是isa_t类型的指针. isa 共用体
union isa_t
{
isa_t() { }
isa_t(uintptr_t value) : bits(value) { }
Class cls; ///> 表明所属的类
uintptr_t bits;
# define ISA_MASK 0x0000000ffffffff8ULL
# define ISA_MAGIC_MASK 0x000003f000000001ULL
# define ISA_MAGIC_VALUE 0x000001a000000001ULL
struct {
uintptr_t nonpointer : 1;
uintptr_t has_assoc : 1;
uintptr_t has_cxx_dtor : 1;
uintptr_t shiftcls : 33; // MACH_VM_MAX_ADDRESS 0x1000000000
uintptr_t magic : 6;
uintptr_t weakly_referenced : 1;
uintptr_t deallocating : 1;
uintptr_t has_sidetable_rc : 1;
uintptr_t extra_rc : 19;
# define RC_ONE (1ULL<<45)
# define RC_HALF (1ULL<<18)
};
};
objc_class 与 objc_object 的关系 元类
objc_class也是一个objc_object类型，这意味着，objc_class中也有一个属性isa，而这个isa，可以表示当前类属于（注意不是继承）哪个类。而这种说明类是属于哪个类的类，我们称之为元类（meta-class）
类保存了对象方法
元类保存了 类方法
类对象 元类对象
类对象存储实力方法列表等信息
元类对象存储类方法等信息
objc_object 通过isa找到他的 类对象 得到实力方法
类继承与 objc_object 他的isa指针指向他的元类对象
元类对象 的isa 指向 根元类对象
跟元类 对象 的superclass 指针指向的是跟类对象
调用类方法。和调用实力方法的区别：
调用的类方法 当我们调用的类方法 找不到的时候 就回调用父类的同名的实力方法
··
iOS源码解析：runtime<一> isa，class底层结构窥探
iOS源码解析：runtime<三>super,isKindOfClass,isMemberOfClass
iOS引用计数管理之揭秘计数存储
