Runtime

1、Runtime 基础定义

1.1、对象模型

1.2、IMP

// 实例对象/类对象 都可以调用
- (IMP)methodForSelector:(SEL)aSelector;
// 类对象调用
+ (IMP)instanceMethodForSelector:(SEL)aSelector;

IMP function1 = imp_implementationWithBlock(^(id self, NSString *text){
 NSLog(@"this is a test block ~");
}) ;
 
const char *types = sel_getName(@selector(testMethod:)) ;
class_replaceMethod([Persion class], @selector(testMethod:), function1, types) ;
 

1.3、Method

typedef struct method_t *Method;
struct method_t { 
	SEL name;				// 函数名
	const char *types; 		// 标记
	IMP imp; 				// 指针
};

1.4、Property

typedef struct property_t *objc_property_t;
struct property_t {
	const char *name; 
	const char *attributes;
};

// 实例对象属性列表
objc_property_t * class_copyPropertyList􏴓Class cls􏰏unsigned int * outCount􏴔 
// 协议属性列表
objc_property_t * protocol_copyPropertyList􏴓Protocol * proto􏰏unsigned int * outCou nt􏴔

objc_property_t class_getProperty􏴓Class cls􏰏const char * name􏴔
objc_property_t protocol_getProperty􏴓Protocol * proto􏰏const char * name􏰏BOOL isRe quiredProperty􏰏BOOL isInstanceProperty􏴔

1.5、内存布局

1.6、方法传参

2、Runtime 结构体

2.1、对象结构体

struct objc_object{
private:
	isa_t isa;
}

// isa 定义如下:
union isa_t {
 isa_t() { }
 isa_t(uintptr_t value) : bits(value) { }
 Class cls;
 uintptr_t bits;
# if __arm64__
# define ISA_MASK 0x0000000ffffffff8ULL
# define ISA_MAGIC_MASK 0x000003f000000001ULL
# define ISA_MAGIC_VALUE 0x000001a000000001ULL
 
 struct {
	 uintptr_t nonpointer 				: 1;	// 32位还是64位
	 uintptr_t has_assoc				: 1;	// 对象是否含有或者曾经含有关联引用,没有则可以更快的是否对象
 uintptr_t has_cxx_dtor			: 1;	// 是否有 C++或者 OC 的析构函数
 uintptr_t shiftcls				: 33;	// 对象指向类的内存地址,也就是 isa 指向的地址
 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)
 };
# elif	__x86_64__
// ...
# elif	__armv7__
// ...
# else
//...
};
 

2.2、类结构体

struct objc_class : objc_object {
	// class isa
	Class superclass;			// 指向起父类的 objc_class
	cache_t cache;				// 处理已经调用方法的缓存
	// bits 内部定义了 uintptr 类型的 bits 成员变量,存储了 class_rw_t 的地址,定义了一些基本操作,如 获取 class_rw_t、raw isa状态,是否 swift等函数
	class_data_bits bits;	
	
	class_rw_t *data() {
		return bits.data();
	}	
	void setData(class_rw_t *nweData) {
		bit.setData(newData) ;
	}
	// ...
}
// 函数实现: 通过对 uintptr_t 类型的 bits 变量做位运算查找对用的值,获取 class_rw_t 指针
uintptr_t 本质上是􏲭􏴝􏲬􏰲􏰝􏳍 unsigned long 的􏰒 typedef,unsigned long 在􏰀64位处理器中占 􏴑􏳢􏴞􏰁􏳰8字节,正好是􏳲􏰂􏱈􏳴􏰲64位的二进制,通过􏴠􏰣􏱚􏰑 FAST_DATA_MASK 转换为二进制后是取出􏴡􏴢􏲊􏴟􏱷􏴠􏲹􏰂􏰲􏱲 bits 中的 􏰁􏰒47-3􏰒􏲶􏴣􏰂􏱈 􏳴􏰲􏱲位置,正好是 􏱳class_rw_t 􏳈􏴐􏰣指针
class_rw_t* data() {
return (class_rw_t *)(bits & FAST_DATA_MASK);
}

3、Runtime 源码分析

3.1、对象的初始化

3.2、addMethod 方法实现

static IMP 
addMethod(Class cls, SEL name, IMP imp, const char *types, bool replace)
{
 IMP result = nil;
 
 method_t *m;
 
 if ((m = getMethodNoSuper_nolock(cls, name))) {
 // already exists
 if (!replace) {		// 直接返回
 result = m->imp;
 } else {	 // 替换
 result = _method_setImplementation(cls, m, imp);
 }
 } else {		// 创建新的
 // fixme optimize
 method_list_t *newlist;
 newlist = (method_list_t *)calloc(sizeof(*newlist), 1);
 newlist->entsizeAndFlags = 
 (uint32_t)sizeof(method_t) | fixed_up_method_list;
 newlist->count = 1;
 newlist->first.name = name;
 newlist->first.types = strdupIfMutable(types);
 newlist->first.imp = imp;
 
 // 添加到列表
 prepareMethodLists(cls, &newlist, 1, NO, NO);
 cls->data()->methods.attachLists(&newlist, 1);
 flushCaches(cls);	// 缓存
 result = nil;
 }
 return result;
}

3.3、添加 ivar

// add ivar
- (void)runtimeAddIvar {
 // create class :getClass 判断类比是否存在, superclass 判断父类是否合适
 Class testClass = objc_allocateClassPair([NSObject class], "TestClass", 0) ;
 BOOL isAdd = class_addIvar(testClass, "password", sizeof(NSString *), log2(sizeof(NSString *)), @encode(NSString *)) ;
 objc_registerClassPair(testClass) ;
 if (isAdd) {
 id object = [[testClass alloc] init];
 [object setValue:@"123456" forKey:@"password"];
 NSLog(@"testClass `s password is %@", [object valueForKey:@"password"]);
 }
}
/** 以下方法实现 */
// 创建类
Class objc_allocateClassPair(Class superclass, const char *name,
 size_t extraBytes) {
 Class cls, meta;
 // 判断类名是否已经存在,supperClass 是否合适
 if (getClass(name) || !verifySuperclass(superclass, true/*rootOK*/)) {
 return nil;
 }
 // 创建元类和类 -- 分配内存空间
 cls = alloc_class_for_subclass(superclass, extraBytes);
 meta = alloc_class_for_subclass(superclass, extraBytes);
 // 初始化操作
 objc_initializeClassPair_internal(superclass, name, cls, meta);
 return cls;
}
// 注册类
void objc_registerClassPair(Class cls) {
 
 // Clear "under construction" bit, set "done constructing" bit
 cls->ISA()->changeInfo(RW_CONSTRUCTED, RW_CONSTRUCTING | RW_REALIZING);
 cls->changeInfo(RW_CONSTRUCTED, RW_CONSTRUCTING | RW_REALIZING);
 // Add to named class table.
 addNamedClass(cls, cls->data()->ro->name);
}
static void addNamedClass(Class cls, const char *name, Class replacing = nil) {
 Class old;
 if ((old = getClass(name)) && old != replacing) {
 // 递归注册元类和类
 inform_duplicate(name, old, cls);
 addNonMetaClass(cls);
 } else {
 // 注册类实现方式
 NXMapInsert(gdb_objc_realized_classes, name, cls);
 }
}

3.4、数据访问

int a = 20 ; --- int 代表四个字节的长度。
char b = "i";--- char 代表一个字节的长度。

3.5、Protocol

struct protocol_t : objc_object {
 const char *mangledName;
 struct protocol_list_t *protocols;
 method_list_t *instanceMethods;
 method_list_t *classMethods;
 method_list_t *optionalInstanceMethods;
 method_list_t *optionalClassMethods;
 property_list_t *instanceProperties;
 uint32_t size; // sizeof(protocol_t)
 uint32_t flags;
 // Fields below this point are not always present on disk.
 const char **_extendedMethodTypes;
 const char *_demangledName;
 property_list_t *_classProperties;
};

// 创建新的Protocol,创建后还需要调用下面的register方法
Protocol *
objc_allocateProtocol(const char *name)
{
	// 协议已经存在,则创建失败
 if (getProtocol(name)) {
 return nil;
 }
 protocol_t *result = (protocol_t *)calloc(sizeof(protocol_t), 1);
 // 下面的cls是__IncompleteProtocol类,表示是未完成的Protocol
 extern objc_class OBJC_CLASS_$___IncompleteProtocol;
 Class cls = (Class)&OBJC_CLASS_$___IncompleteProtocol;
 result->initProtocolIsa(cls);
 result->size = sizeof(protocol_t);
 // fixme mangle the name if it looks swift-y?
 result->mangledName = strdupIfMutable(name);
 // fixme reserve name without installing
 return (Protocol *)result;
}
// 向protocol的哈希表中,注册新创建的Protocol对象
void objc_registerProtocol(Protocol *proto_gen) 
{
 protocol_t *proto = newprotocol(proto_gen);
 rwlock_writer_t lock(runtimeLock);
 extern objc_class OBJC_CLASS_$___IncompleteProtocol;
 Class oldcls = (Class)&OBJC_CLASS_$___IncompleteProtocol;
 extern objc_class OBJC_CLASS_$_Protocol;
 Class cls = (Class)&OBJC_CLASS_$_Protocol;
 // 如果已经被注册到哈希表中,则直接返回
 if (proto->ISA() == cls) {
 _objc_inform("objc_registerProtocol: protocol '%s' was already "
 "registered!", proto->nameForLogging());
 return;
 }
 // 如果当前protocol的isa不是__IncompleteProtocol,表示这个protocol是有问题的,则返回
 if (proto->ISA() != oldcls) {
 _objc_inform("objc_registerProtocol: protocol '%s' was not allocated "
 "with objc_allocateProtocol!", proto->nameForLogging());
 return;
 }
 // NOT initProtocolIsa(). The protocol object may already 
 // have been retained and we must preserve that count.
 proto->changeIsa(cls);
 NXMapKeyCopyingInsert(protocols(), proto->mangledName, proto);
}

3.6、SEL

static SEL sel_alloc(const char *name, bool copy) {
	return (SEL)(copy ? strdupIfMutable(name) : name); 
}

3.7、对等交换协议

http://www.gnustep.org/
苹果的一套对等交换源码,将 OC 代码重新实现了一遍,内部实现大致和苹果的类似。

4、Runtime 加载过程

4.1、程序中动态库优点

4.2、加载过程

4.3、map images

// runtime加载入口
void _objc_init(void)
{
/* 各种资源的 init 
 static bool initialized = false;
 if (initialized) return;
 initialized = true;

 // fixme defer initialization until an objc-using image is found?
 environ_init();
 tls_init();
 static_init();
 lock_init();
 exception_init();
 */
 _dyld_objc_notify_register(&map_images, load_images, unmap_image);
}
// 加载所有image
void
map_images(unsigned count, const char * const paths[],
 const struct mach_header * const mhdrs[])
{
 rwlock_writer_t lock(runtimeLock);
 return map_images_nolock(count, paths, mhdrs);
}
void 
map_images_nolock(unsigned mhCount, const char * const mhPaths[],
 const struct mach_header * const mhdrs[])
{
 if (hCount > 0) {
 _read_images(hList, hCount, totalClasses, unoptimizedTotalClasses);
 }
}

void _read_images(header_info **hList, uint32_t hCount, int totalClasses, int unoptimizedTotalClasses)
{
 header_info *hi;
 uint32_t hIndex;
 size_t count;
 size_t i;
 Class *resolvedFutureClasses = nil;
 size_t resolvedFutureClassCount = 0;
 static bool doneOnce;
 TimeLogger ts(PrintImageTimes);
 runtimeLock.assertWriting();
#define EACH_HEADER \
 hIndex = 0; \
 hIndex < hCount && (hi = hList[hIndex]); \
 hIndex++
 if (!doneOnce) {
 doneOnce = YES;
 // 0、实例化存储类的哈希表,并且根据当前类数量做动态扩容
 int namedClassesSize = 
 (isPreoptimized() ? unoptimizedTotalClasses : totalClasses) * 4 / 3;
 gdb_objc_realized_classes =
 NXCreateMapTable(NXStrValueMapPrototype, namedClassesSize);
 }
 // 1、由编译器读取类列表,并将所有类添加到类的哈希表中,并且标记懒加载的类并初始化内存空间
 for (EACH_HEADER) {
 if (! mustReadClasses(hi)) {
 // Image is sufficiently optimized that we need not call readClass()
 continue;
 }
 bool headerIsBundle = hi->isBundle();
 bool headerIsPreoptimized = hi->isPreoptimized();
 /** 将新类添加到哈希表中 */
 
 // 从编译后的类列表中取出所有类,获取到的是一个classref_t类型的指针
 classref_t *classlist = _getObjc2ClassList(hi, &count);
 for (i = 0; i < count; i++) {
 // 数组中会取出OS_dispatch_queue_concurrent、OS_xpc_object、NSRunloop等系统类,例如CF、Fundation、libdispatch中的类。以及自己创建的类
 Class cls = (Class)classlist[i];
 // 通过readClass函数获取处理后的新类,内部主要操作ro和rw结构体
 Class newCls = readClass(cls, headerIsBundle, headerIsPreoptimized);
 // 初始化所有懒加载的类需要的内存空间
 if (newCls != cls && newCls) {
 // 将懒加载的类添加到数组中
 resolvedFutureClasses = (Class *)
 realloc(resolvedFutureClasses, 
 (resolvedFutureClassCount+1) * sizeof(Class));
 resolvedFutureClasses[resolvedFutureClassCount++] = newCls;
 }
 }
 }
 
 // 2、将未映射Class和Super Class重映射,被remap的类都是非懒加载的类
 if (!noClassesRemapped()) {
 for (EACH_HEADER) {
 // 重映射Class,注意是从_getObjc2ClassRefs函数中取出类的引用
 Class *classrefs = _getObjc2ClassRefs(hi, &count);
 for (i = 0; i < count; i++) {
 remapClassRef(&classrefs[i]);
 }
 // 重映射父类
 classrefs = _getObjc2SuperRefs(hi, &count);
 for (i = 0; i < count; i++) {
 remapClassRef(&classrefs[i]);
 }
 }
 }
 // 3、将所有SEL都注册到哈希表中,是另外一张哈希表
 static size_t UnfixedSelectors;
 sel_lock();
 for (EACH_HEADER) {
 if (hi->isPreoptimized()) continue;
 bool isBundle = hi->isBundle();
 // 取出的是字符串数组,例如首地址是"class"
 SEL *sels = _getObjc2SelectorRefs(hi, &count);
 UnfixedSelectors += count;
 for (i = 0; i < count; i++) {
 // sel_cname函数内部就是将SEL强转为常量字符串
 const char *name = sel_cname(sels[i]);
 // 注册SEL的操作
 sels[i] = sel_registerNameNoLock(name, isBundle);
 }
 }
 sel_unlock();
 
 // 4、修复旧的函数指针调用遗留
 for (EACH_HEADER) {
 message_ref_t *refs = _getObjc2MessageRefs(hi, &count);
 if (count == 0) continue;
 for (i = 0; i < count; i++) {
 // 内部将常用的alloc、objc_msgSend等函数指针进行注册,并fix为新的函数指针
 fixupMessageRef(refs+i);
 }
 }
 // 5、遍历所有协议列表,并且将协议列表加载到Protocol的哈希表中
 for (EACH_HEADER) {
 extern objc_class OBJC_CLASS_$_Protocol;
 // cls = Protocol类,所有协议和对象的结构体都类似,isa都对应Protocol类
 Class cls = (Class)&OBJC_CLASS_$_Protocol;
 assert(cls);
 // 获取protocol哈希表
 NXMapTable *protocol_map = protocols();
 bool isPreoptimized = hi->isPreoptimized();
 bool isBundle = hi->isBundle();
 // 从编译器中读取并初始化Protocol
 protocol_t **protolist = _getObjc2ProtocolList(hi, &count);
 for (i = 0; i < count; i++) {
 readProtocol(protolist[i], cls, protocol_map, 
 isPreoptimized, isBundle);
 }
 }
 
 // 6、修复协议列表引用,优化后的images可能是正确的,但是并不确定
 for (EACH_HEADER) {
 // 需要注意到是,下面的函数是_getObjc2ProtocolRefs,和上面的_getObjc2ProtocolList不一样
 protocol_t **protolist = _getObjc2ProtocolRefs(hi, &count);
 for (i = 0; i < count; i++) {
 remapProtocolRef(&protolist[i]);
 }
 }
 
 // 7、实现非懒加载的类,对于load方法和静态实例变量
 for (EACH_HEADER) {
 classref_t *classlist = 
 _getObjc2NonlazyClassList(hi, &count);
 for (i = 0; i < count; i++) {
 Class cls = remapClass(classlist[i]);
 if (!cls) continue;
 // 实现所有非懒加载的类(实例化类对象的一些信息,例如rw)
 realizeClass(cls);
 }
 }
 
 // 8、遍历resolvedFutureClasses数组,实现所有懒加载的类
 if (resolvedFutureClasses) {
 for (i = 0; i < resolvedFutureClassCount; i++) {
 // 实现懒加载的类
 realizeClass(resolvedFutureClasses[i]);
 resolvedFutureClasses[i]->setInstancesRequireRawIsa(false/*inherited*/);
 }
 free(resolvedFutureClasses);
 } 
 // 9、发现和处理所有Category
 for (EACH_HEADER) {
 // 外部循环遍历找到当前类,查找类对应的Category数组
 category_t **catlist = 
 _getObjc2CategoryList(hi, &count);
 bool hasClassProperties = hi->info()->hasCategoryClassProperties();
 // 内部循环遍历当前类的所有Category
 for (i = 0; i < count; i++) {
 category_t *cat = catlist[i];
 Class cls = remapClass(cat->cls);
 
 // 首先,通过其所属的类注册Category。如果这个类已经被实现,则重新构造类的方法列表。
 bool classExists = NO;
 if (cat->instanceMethods || cat->protocols 
 || cat->instanceProperties) 
 {
 // 将Category添加到对应Class的value中,value是Class对应的所有category数组
 addUnattachedCategoryForClass(cat, cls, hi);
 // 将Category的method、protocol、property添加到Class
 if (cls->isRealized()) {
 remethodizeClass(cls);
 classExists = YES;
 }
 }
 // 这块和上面逻辑一样,区别在于这块是对Meta Class做操作,而上面则是对Class做操作
 // 根据下面的逻辑,从代码的角度来说,是可以对原类添加Category的
 if (cat->classMethods || cat->protocols 
 || (hasClassProperties && cat->_classProperties)) 
 {
 addUnattachedCategoryForClass(cat, cls->ISA(), hi);
 if (cls->ISA()->isRealized()) {
 remethodizeClass(cls->ISA());
 }
 }
 }
 }
 
 // 10、初始化从磁盘中加载的所有类,发现Category必须是最后执行的
 // 从runtime objc4-532版本源码来看,DebugNonFragileIvars字段一直是-1,所以不会进入这个方法中
 if (DebugNonFragileIvars) {
 realizeAllClasses();
 }
#undef EACH_HEADER
}

4.4、load images

4.5、load 源码分析

void
load_images(const char *path __unused, const struct mach_header *mh)
{
 // Return without taking locks if there are no +load methods here.
 if (!hasLoadMethods((const headerType *)mh)) return;
 
 // 准备Class list和Category list
 prepare_load_methods((const headerType *)mh);
 
 // 调用已经准备好的Class list和Category list
 call_load_methods();
}

// 准备Class list 和 Category list
void prepare_load_methods(const headerType *mhdr)
{
 size_t count, i;
 // 获取到非懒加载的类的列表
 classref_t *classlist = 
 _getObjc2NonlazyClassList(mhdr, &count);
 for (i = 0; i < count; i++) {
 // 设置Class的调用列表
 schedule_class_load(remapClass(classlist[i]));
 }
 
 // 获取到非懒加载的Category列表
 category_t **categorylist = _getObjc2NonlazyCategoryList(mhdr, &count);
 for (i = 0; i < count; i++) {
 category_t *cat = categorylist[i];
 Class cls = remapClass(cat->cls);
 // 忽略弱链接的类别
 if (!cls) continue; // category for ignored weak-linked class
 // 实例化所属的类
 realizeClass(cls);
 assert(cls->ISA()->isRealized());
 // 设置Category的调用列表
 add_category_to_loadable_list(cat);
 }
}
static void schedule_class_load(Class cls)
{
 if (!cls) return;
 // 已经添加Class的load方法到调用列表中
 if (cls->data()->flags & RW_LOADED) return;
 // 确保super已经被添加到load列表中,默认是整个继承者链的顺序
 schedule_class_load(cls->superclass);
 
 // 将IMP和Class添加到调用列表
 add_class_to_loadable_list(cls);
 // 设置Class的flags,表示已经添加Class到调用列表中
 cls->setInfo(RW_LOADED); 
}
void add_category_to_loadable_list(Category cat)
{
 IMP method;
 
 // 获取Category的load方法的IMP
 method = _category_getLoadMethod(cat);
 // 如果Category没有load方法则return
 if (!method) return;
 
 // 如果已经使用的大小等于数组大侠,对数组进行动态扩容。
 if (loadable_categories_used == loadable_categories_allocated) {
 loadable_categories_allocated = loadable_categories_allocated*2 + 16;
 loadable_categories = (struct loadable_category *)
 realloc(loadable_categories,
 loadable_categories_allocated *
 sizeof(struct loadable_category));
 }
 loadable_categories[loadable_categories_used].cat = cat;
 loadable_categories[loadable_categories_used].method = method;
 loadable_categories_used++;
}

void call_load_methods(void)
{
 bool more_categories;
 void *pool = objc_autoreleasePoolPush();
 do {	// 反复循环执行 call_class_loads 函数,直到数组中每天接执行的 load 方法。
 // 1. Repeatedly call class +loads until there aren't any more
 while (loadable_classes_used > 0) {
 call_class_loads();
 }
 // 2. Call category +loads ONCE
 more_categories = call_category_loads();
 // 3. Run more +loads if there are classes OR more untried categories
 } while (loadable_classes_used > 0 || more_categories);
 objc_autoreleasePoolPop(pool);
}

4.6、initialize

4.7、initialize 源码分析

// 第一次调用类的方法,初始化类对象
void _class_initialize(Class cls)
{
 Class supercls;
 bool reallyInitialize = NO;
 // 递归初始化父类。initizlize不用显式的调用super,因为runtime已经在内部调用了
 supercls = cls->superclass;
 if (supercls && !supercls->isInitialized()) {
 _class_initialize(supercls);
 }
 // Try to atomically set CLS_INITIALIZING.
 {
 monitor_locker_t lock(classInitLock);
 if (!cls->isInitialized() && !cls->isInitializing()) {
 cls->setInitializing();
 reallyInitialize = YES;
 }
 }
 
 if (reallyInitialize) {
 
 _setThisThreadIsInitializingClass(cls);
 if (MultithreadedForkChild) {
 performForkChildInitialize(cls, supercls);
 return;
 }
 @try {
 	// 通过objc_msgSend()函数调用initialize方法
 callInitialize(cls);
 }
 @catch (...) {
 @throw;
 }
 @finally
 {
 // Done initializing.
 // 执行initialize方法后,进行系统的initialize过程
 lockAndFinishInitializing(cls, supercls);
 }
 return;
 }
 
 else if (cls->isInitializing()) {
 if (_thisThreadIsInitializingClass(cls)) {
 return;
 } else if (!MultithreadedForkChild) {
 waitForInitializeToComplete(cls);
 return;
 } else {
 _setThisThreadIsInitializingClass(cls);
 performForkChildInitialize(cls, supercls);
 }
 }
}

	[object testMethod];
	
	objc_msgSend(object, @selector(testMethod)) ;

- (void)method {
	id target = getTheReceiver();
	SEL method = getTheMethod();
	
	if ( target == self || method == _cmd ) return nil;
	
	return [target performSelector:method]; 
}

5.4、消息发送流程

5.5、cache_t

5.6、总结

void dynamicResolveMethod(id self, SEL _cmd){
 NSLog(@"-------- 方法未实现~");
}
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wobjc-protocol-method-implementation"
+(BOOL)resolveInstanceMethod:(SEL)sel {
 
 const char *types = sel_getName(sel) ;
 NSLog(@"--- method name: %s", types);
 class_addMethod([self class], sel, (IMP)dynamicResolveMethod, types) ;
 return YES ;
}
#pragma clang diagnostic pop

	获取真正的类
	objc_getClass("__NSArrayI") ;

__attribute__((objc_subclassing_restricted))

// testMethod 方法必须调用 [super testMethod];
- (void)testMethod __attribute__((objc_requires_super)); 

__attribute__((overloadable)) void testMethod(int age) {}
__attribute__((overloadable)) void testMethod(NSString *name) {} 
__attribute__((overloadable)) void testMethod(BOOL gender) {}

__attribute__((objc_runtime_name("TestObject"))) 
@interface Object : NSObject
@end
// Testclass
NSStringFormClass([TestObject class]);

	Object *obj __attribute__((cleanup(aaaaaaa))) = [Object new];
	
	变量释放之前会执行
	static void aaaaaaa(NSObject **obj) {
		NSLog(@"--- %@", *obj);
	}

	NSObject *aa __attribute__((unused)) = [NSObject new];