runloop和runtime的区别

最新推荐文章于 2020-06-15 15:46:21 发布

Cola可乐

最新推荐文章于 2020-06-15 15:46:21 发布

阅读量2.3k

点赞数

分类专栏： Runloop

本文链接：https://blog.csdn.net/shi520fu/article/details/61195694

版权

Runloop 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一.RunLoop:

Runloop是事件接收和分发机制的一个实现。

Runloop提供了一种异步执行代码的机制，不能并行执行任务。

在主队列中，Main RunLoop直接配合任务的执行，负责处理UI事件、定时器以及其他内核相关事件。

(1).RunLoop的主要目的：

保证程序执行的线程不会被系统终止。

(2).什么时候使用Runloop ？

当需要和该线程进行交互的时候才会使用Runloop.

每一个线程都有其对应的RunLoop，但是默认非主线程的RunLoop是没有运行的，需要为RunLoop添加至少一个事件源，然后去run它。

一般情况下我们是没有必要去启用线程的RunLoop的，除非你在一个单独的线程中需要长久的检测某个事件。

主线程默认有Runloop。当自己启动一个线程，如果只是用于处理单一的事件，则该线程在执行完之后就退出了。所以当我们需要让该线程监听某项事务

时，就得让线程一直不退出，runloop就是这么一个循环，没有事件的时候，一直卡着，有事件来临了，执行其对应的函数。

RunLoop,正如其名所示,是线程进入和被线程用来相应事件以及调用事件处理函数的地方.需要在代码中使用控制语句实现RunLoop的循环,也就是说,需要代码提供while或者for循环来驱动RunLoop.

在这个循环中,使用一个runLoop对象[NSRunloop currentRunloop]执行接收消息,调用对应的处理函数.

Runloop接收两种源事件:input sources和timer sources。

input sources 传递异步事件，通常是来自其他线程和不同的程序中的消息；

timer sources(定时器) 传递同步事件（重复执行或者在特定时间上触发）。

除了处理input sources，Runloop

也会产生一些关于本身行为的notificaiton。注册成为Runloop的observer，可以接收到这些notification，做一些额外

的处理。（使用CoreFoundation来成为runloop的observer）。

Runloop工作的特点:

1>当有时间发生时,Runloop会根据具体的事件类型通知应用程序作出相应;

2>当没有事件发生时,Runloop会进入休眠状态,从而达到省电的目的;

3>当事件再次发生时,Runloop会被重新唤醒,处理事件.

提示:一般在开发中很少会主动创建Runloop,而通常会把事件添加到Runloop中.

二.Runtime:

RunTime简称运行时。就是系统在运行的时候的一些机制，其中最主要的是消息机制。对于C语言，函数的调用在编译的时候会决定调用哪个函数（

C语言的函数调用请看这里

）。编译完成之后直接顺序执行，无任何二义性。OC的函数调用成为消息发送。属于动态调用过程。在编译的时候并不能决定真正调用哪个函数（事实证明，在编

译阶段，OC可以调用任何函数，即使这个函数并未实现，只要申明过就不会报错。而C语言在编译阶段就会报错）。只有在真正运行的时候才会根据函数的名称找

到对应的函数来调用。

那OC是怎么实现动态调用的呢？下面我们来看看OC通过发送消息来达到动态调用的秘密。假如在OC中写了这样的一个代码：

[objc] view plain?

<span style="font-size:18px;">[obj makeText];</span>

其中obj是一个对象，makeText是一个函数名称。对于这样一个简单的调用。在编译时RunTime会将上述代码转化成

[objc] view plain?

objc_msgSend(obj,@selector(makeText));

首先我们来看看obj这个对象，iOS中的obj都继承于NSObject。

[objc] view plain?

@interface NSObject <nsobject> {

Class isa OBJC_ISA_AVAILABILITY;

}</nsobject>

在NSObjcet中存在一个Class的isa指针。然后我们看看Class：

[objc] view plain?

typedef struct objc_class *Class;

struct objc_class {

Class isa; // 指向metaclass

Class super_class ; // 指向其父类

const charchar *name ; // 类名

long version ; // 类的版本信息，初始化默认为0，可以通过runtime函数class_setVersion和class_getVersion进行修改、读取

long info; // 一些标识信息,如CLS_CLASS (0x1L) 表示该类为普通 class ，其中包含对象方法和成员变量;CLS_META (0x2L) 表示该类为 metaclass，其中包含类方法;

long instance_size ; // 该类的实例变量大小(包括从父类继承下来的实例变量);

struct objc_ivar_list *ivars; // 用于存储每个成员变量的地址

struct objc_method_list **methodLists ; // 与 info 的一些标志位有关,如CLS_CLASS (0x1L),则存储对象方法，如CLS_META (0x2L)，则存储类方法;

struct objc_cache *cache; // 指向最近使用的方法的指针，用于提升效率；

struct objc_protocol_list *protocols; // 存储该类遵守的协议

}

我们可以看到，对于一个Class类中，存在很多东西，下面我来一一解释一下：

Class

isa：指向metaclass，也就是静态的Class。一般一个Obj对象中的isa会指向普通的Class，这个Class中存储普通成员变量和对

象方法（“-”开头的方法），普通Class中的isa指针指向静态Class，静态Class中存储static类型成员变量和类方法（“+”开头的方

法）。

Class super_class:指向父类，如果这个类是根类，则为NULL。

下面一张图片很好的描述了类和对象的继承关系：

注意：所有metaclass中isa指针都指向跟metaclass。而跟metaclass则指向自身。

Root metaclass是通过继承Root class产生的。与root class结构体成员一致，也就是前面提到的结构。不同的是Root

metaclass的isa指针指向自身。

Class类中其他的成员这里就先不做过多解释了，下面我们来看看：

@selector (makeText)：

这是一个SEL方法选择器。SEL其主要作用是快速的通过方法名字（makeText）查找到对应方法的函数指针，然后调用其函数。SEL其本身是一个

Int类型的一个地址，地址中存放着方法的名字。对于一个类中。每一个方法对应着一个SEL。所以iOS类中不能存在2个名称相同的方法，即使参数类型不

同，因为SEL是根据方法名字生成的，相同的方法名称只能对应一个SEL。

下面我们就来看看具体消息发送之后是怎么来动态查找对应的方法的。

首先，编译器将代码[obj makeText];转化为objc_msgSend(obj, @selector

(makeText));，在objc_msgSend函数中。首先通过obj的isa指针找到obj对应的class。在Class中先去cache中

通过SEL查找对应函数method（猜测cache中method列表是以SEL为key通过hash表来存储的，这样能提高函数查找速度），若

cache中未找到。再去methodList中查找，若methodlist中未找到，则取superClass中查找。若能找到，则将method加

入到cache中，以方便下次查找，并通过method中的函数指针跳转到对应的函数中去执行。

runtime的使用

//runtime的使用

//runTime书写形式

1、id类型表示对象接受体

2、SEL 选择器用于存储方法消息

//C语言函数直接书写不会运行OC转C阶段因此运行效率很高

#pragma mark c语言书写接受体和消息

//给谁发消息发的消息是什么

objc_msgSend(self, @selector(loadData));

//OC

[self startRequestWithUrl:@"http://www.baidu.com"];

//runTime

objc_msgSend(self, @selector(startRequestWithUrl:),@"http://www.baidu.com");

我们写的代码在程序运行过程中都会被转化成runtime的C代码执行，例如[target doSomething];会被转化成objc_msgSend(target, @selector(doSomething));。

OC中一切都被设计成了对象，我们都知道一个类被初始化成一个实例，这个实例是一个对象。实际上一个类本质上也是一个对象，在runtime中用结构体表示。

相关的定义：

/// 描述类中的一个方法

typedef struct objc_method *Method;

/// 实例变量

typedef struct objc_ivar *Ivar;

/// 类别Category

typedef struct objc_category *Category;

/// 类中声明的属性

typedef struct objc_property *objc_property_t;

类在runtime中的表示

//类在runtime中的表示

struct objc_class {

Class isa;//指针，顾名思义，表示是一个什么，

//实例的isa指向类对象，类对象的isa指向元类

#if !__OBJC2__

Class super_class; //指向父类

const char *name; //类名

long version;

long info;

long instance_size

struct objc_ivar_list *ivars //成员变量列表

struct objc_method_list **methodLists; //方法列表

struct objc_cache *cache;//缓存

//一种优化，调用过的方法存入缓存列表，下次调用先找缓存

struct objc_protocol_list *protocols //协议列表

#endif

} OBJC2_UNAVAILABLE;

/* Use `Class` instead of `struct objc_class *` */

获取列表

有时候会有这样的需求，我们需要知道当前类中每个属性的名字（比如字典转模型，字典的Key和模型对象的属性名字不匹配）。

#pragma mark 给类别中添加属性

为类添加类别默认不允许添加属性只允许添加方法

使用runTime为类添加类别中的属性

.h文件

@property (nonatomic,copy) NSString * name;

.m文件

//需要包含头文件之后重写setter和getter方法

#import <objc/runtime.h>

static void * key = "Key";

//如果需要对类别添加属性需使用runtime重写set get方法

- (void)setName:(NSString *)name{

// self.name = name;//本质即为set方法

// _name = name;

//runtime赋值操作

1、调用的对象本身self

2、需要一个静态的C语言指针保证通过runtime进行赋值取值操作时操作的为同一个对象

3、给哪个属性进行赋值

4、C语言的属性修饰对应OC中的属性修饰符

objc_setAssociatedObject(self, key, name, OBJC_ASSOCIATION_COPY_NONATOMIC);

}

- (NSString*)name{

// return _name;

1、仍然为调用的对象

2、静态C语言指针

return objc_getAssociatedObject(self, key);

}

#pragma mark 获取类的一些信息（包括属性列表，方法列表，成员变量列表，和遵循的协议列表）

///通过运行时获取当前对象的所有属性的名称，以数组的形式返回

//#import <objc/runtime.h> 头文件

- (void) allPropertyNamesValueModel:(NewModel *)vModel parentModel:(NewModel *)pModel

{

///存储属性的个数

unsigned int propertyCount = 0;

///通过运行时获取当前类的属性

objc_property_t *propertys = class_copyPropertyList([NewModel class], &propertyCount);

//把属性放到数组中

for (int i = 0; i < propertyCount; i ++) {

///取出第一个属性

objc_property_t property = propertys[i];

const char * propertyName = property_getName(property);

NSString * pName = [NSString stringWithUTF8String:propertyName];

[pModel setValue:[vModel valueForKey:pName] forKey:pName];

}

///释放

free(propertys);

}

有时候会有这样的需求，我们需要知道当前类中每个属性的名字（比如字典转模型，字典的Key和模型对象的属性名字不匹配）。

我们可以通过runtime的一系列方法获取类的一些信息（包括属性列表，方法列表，成员变量列表，和遵循的协议列表）。

unsigned int count;

//获取属性列表

objc_property_t *propertyList = class_copyPropertyList([self class], &count);

for (unsigned int i=0; i<count; i++) {

const char *propertyName = property_getName(propertyList[i]);

NSLog(@"property---->%@", [NSString stringWithUTF8String:propertyName]);

}

//获取方法列表

Method *methodList = class_copyMethodList([self class], &count);

for (unsigned int i; i<count; i++) {

Method method = methodList[i];

NSLog(@"method---->%@", NSStringFromSelector(method_getName(method)));

}

//获取成员变量列表

Ivar *ivarList = class_copyIvarList([self class], &count);

for (unsigned int i; i<count; i++) {

Ivar myIvar = ivarList[i];

const char *ivarName = ivar_getName(myIvar);

NSLog(@"Ivar---->%@", [NSString stringWithUTF8String:ivarName]);

}

//获取协议列表

__unsafe_unretained Protocol **protocolList = class_copyProtocolList([self class], &count);

for (unsigned int i; i<count; i++) {

Protocol *myProtocal = protocolList[i];

const char *protocolName = protocol_getName(myProtocal);

NSLog(@"protocol---->%@", [NSString stringWithUTF8String:protocolName]);

}

在Xcode上跑一下看看输出吧，需要给你当前的类写几个属性，成员变量，方法和协议，不然获取的列表是没有东西的。

#pragma mark 将字符串的类名转换为真实的类

NSString * className = @"ViewController";

//NSClassFromString 是一个c函数

Class class = NSClassFromString(className);

//创建该类的对象

id vc = [[class alloc]init];//runtime创建形式

id vc2 = [[ViewController alloc]init];//普通创建形式

#pragma mark 方法调用

让我们看一下方法调用在运行时的过程（参照前文类在runtime中的表示）

如果用实例对象调用实例方法，会到实例的isa指针指向的对象（也就是类对象）操作。

如果调用的是类方法，就会到类对象的isa指针指向的对象（也就是元类对象）中操作。

首先，在相应操作的对象中的缓存方法列表中找调用的方法，如果找到，转向相应实现并执行。

如果没找到，在相应操作的对象中的方法列表中找调用的方法，如果找到，转向相应实现执行

如果没找到，去父类指针所指向的对象中执行1，2.

以此类推，如果一直到根类还没找到，转向拦截调用。

如果没有重写拦截调用的方法，程序报错。

以上的过程给我带来的启发：

重写父类的方法，并没有覆盖掉父类的方法，只是在当前类对象中找到了这个方法后就不会再去父类中找了。

如果想调用已经重写过的方法的父类的实现，只需使用super这个编译器标识，它会在运行时跳过在当前的类对象中寻找方法的过程。

拦截调用

在方法调用中说到了，如果没有找到方法就会转向拦截调用。

那么什么是拦截调用呢。

拦截调用就是，在找不到调用的方法程序崩溃之前，你有机会通过重写NSObject的四个方法来处理。

+ (BOOL)resolveClassMethod:(SEL)sel;

+ (BOOL)resolveInstanceMethod:(SEL)sel;

//后两个方法需要转发到其他的类处理

- (id)forwardingTargetForSelector:(SEL)aSelector;

- (void)forwardInvocation:(NSInvocation *)anInvocation;

第一个方法是当你调用一个不存在的类方法的时候，会调用这个方法，默认返回NO，你可以加上自己的处理然后返回YES。

第二个方法和第一个方法相似，只不过处理的是实例方法。

第三个方法是将你调用的不存在的方法重定向到一个其他声明了这个方法的类，只需要你返回一个有这个方法的target。

第四个方法是将你调用的不存在的方法打包成NSInvocation传给你。做完你自己的处理后，调用invokeWithTarget:方法让某个target触发这个方法。

动态添加方法

重写了拦截调用的方法并且返回了YES，我们要怎么处理呢？

有一个办法是根据传进来的SEL类型的selector动态添加一个方法。

首先从外部隐式调用一个不存在的方法：

//隐式调用方法

[target performSelector:@selector(resolveAdd:) withObject:@"test"];

然后，在target对象内部重写拦截调用的方法，动态添加方法。

void runAddMethod(id self, SEL _cmd, NSString *string){

NSLog(@"add C IMP ", string);

}

+ (BOOL)resolveInstanceMethod:(SEL)sel{

//给本类动态添加一个方法

if ([NSStringFromSelector(sel) isEqualToString:@"resolveAdd:"]) {

class_addMethod(self, sel, (IMP)runAddMethod, "v@:*");

}

return YES;

}

其中class_addMethod的四个参数分别是：

Class cls 给哪个类添加方法，本例中是self

SEL name 添加的方法，本例中是重写的拦截调用传进来的selector。

IMP imp 方法的实现，C方法的方法实现可以直接获得。如果是OC方法，可以用+ (IMP)instanceMethodForSelector:(SEL)aSelector;获得方法的实现。

“v@:*”方法的签名，代表有一个参数的方法。

//强制获取并修改私有变量，强制增加及修改私有方法等)

OC是运行时语言，只有在程序运行时，才会去确定对象的类型，并调用类与对象相应的方法。利用runtime机制让我们可以在程序运行时动态修改类、对象中的所有属性、方法，就算是私有方法以及私有属性都是可以动态修改的。本文旨在对runtime的部分特性小试牛刀，更多更全的方法可以参考系统API文件<objc/runtime.h>，demo例子可以参见CSDN的runtime高级编程系列文章。

我们出发吧！

先看一个非常平常的Father类：

复制代码

#import <Foundation/Foundation.h>

@interface Father : NSObject

@property (nonatomic, assign) int age;

@end

复制代码

#import "Father.h"

@interface Father ()

{

　　NSString *_name;

}

- (void)sayHello;

@end

@implementation Father

- (id)init

{

if (self = [super init]) {

_name = @"wengzilin";

[_name copy];

self.age = 27;

}

return self;

}

- (void)dealloc

{

[_name release];

_name = nil;

[super dealloc];

}

- (NSString *)description

{

return [NSString stringWithFormat:@"name:%@, age:%d", _name, self.age];

}

- (void)sayHello

{

NSLog(@"%@ says hello to you!", _name);

}

- (void)sayGoodbay

{

NSLog(@"%@ says goodbya to you!", _name);

}

复制代码

如果你没接触过runtime，那当我问你：“Father之外的类能控制的属性有哪些？能控制的方法有哪些？”时，你估计会回答：“我们可以访问age属性，不能访问_name变量；可以访问age的setter/getter方法，其他方法都不行”。这种回答是OK的，因为教科书上以及面向对象的思想告诉我们，事实如此。但是，我会说，有一种方法是APPLE允许的而且可以不受这些规则限制的途径可以做到想访问什么就访问什么、想修改什么就修改什么，那就是本文的主题：RUNTIME！

现在我们简单地将本文的主题分为两部分：(1)控制私有变量 (2)控制私有函数，因为二者所用的runtime差异较大，函数部分会复杂一些

（1）控制变量

想要控制一个类的私有变量，那第一步就要知道这个类到底有哪些隐藏的变量，以及这些隐藏的变量类型是什么。或许你会说：“这不是很显然吗？.h文件都写着呢！”。如果你真这么想就特错特错了，很多正规的写法都是尽量避免在.h文件中出现私有变量，绝大部分都会选择方法.m文件的extension中，extension就是匿名的category。我猜测这也是一种防止hack的措施吧。不管这些变量放在何处，runtime都可以让他们无所遁形！先看代码，看不懂不要紧，后面会有解释：

复制代码

- (void)tryMember

{

Father *father = [[Father alloc] init];

NSLog(@"before runtime:%@", [father description]);

unsigned int count = 0;

Ivar *members = class_copyIvarList([Father class], &count);

for (int i = 0 ; i < count; i++) {

Ivar var = members[i];

const char *memberName = ivar_getName(var);

const char *memberType = ivar_getTypeEncoding(var);

NSLog(@"%s----%s", memberName, memberType);

}

复制代码

显示如下：

复制代码

2015-03-17 16:10:28.003 WZLCodeLibrary[38574:3149577] before runtime:name:wengzilin, age:27

2015-03-17 16:10:28.003 WZLCodeLibrary[38574:3149577] _name----@"NSString"

2015-03-17 16:10:28.003 WZLCodeLibrary[38574:3149577] _age----i

复制代码

从log中我们知道了，Father类有两个变量，一个公开的包装成属性的age，类型是int，一个花括号{}内的私有变量_name，类型是NSString。代码中标红色的部分就是runtime.h的api，

class_copyIvarList：获取类的所有属性变量，count记录变量的数量IVar是runtime声明的一个宏，是实例变量的意思,instance variable，在runtime中定义为 typedef struct objc_ivar *Ivari

var_getName：将IVar变量转化为字符串

ivar_getTypeEncoding：获取IVar的类型

如果我们现在想对_name动手，不经过Father同意偷偷修改它呢？我们继续往下做：(接着上面的代码)

Ivar m_name = members[0];

object_setIvar(father, m_name, @"zhanfen");

NSLog(@"after runtime:%@", [father description]);

显示如下：

2015-03-17 16:10:28.004 WZLCodeLibrary[38574:3149577] after runtime:name:zhanfen, age:27

我们发现，_name属性被强制改过来了，有wengzilin改为现在zhanfen。

（2）控制私有函数

对于私有变量，我们能做的顶多修改变量的值，但对于私有函数，我们可以玩非常多的花样，比如：在运行时动态添加新的函数、修改私有函数、交换其中两个私有函数的实现、替换私有函数...

同样地，控制的第一步是获得Father类的所有私有方法，我们可以得到.m文件中所有有显式实现的方法以及属性变量的setter+getter方法都会被找到：

复制代码

- (void)tryMemberFunc

{

unsigned int count = 0;

Method *memberFuncs = class_copyMethodList([Father class], &count);//所有在.m文件显式实现的方法都会被找到

for (int i = 0; i < count; i++) {

SEL name = method_getName(memberFuncs[i]);

NSString *methodName = [NSString stringWithCString:sel_getName(name) encoding:NSUTF8StringEncoding];

NSLog(@"member method:%@", methodName);

}

复制代码

显示如下：

复制代码

2015-03-17 17:02:33.343 WZLCodeLibrary[38748:3170794] member method:setAge:

2015-03-17 17:02:33.343 WZLCodeLibrary[38748:3170794] member method:age

2015-03-17 17:02:33.344 WZLCodeLibrary[38748:3170794] member method:sayHello

2015-03-17 17:02:33.344 WZLCodeLibrary[38748:3170794] member method:sayGoodbay

2015-03-17 17:02:33.344 WZLCodeLibrary[38748:3170794] member method:description

2015-03-17 17:02:33.344 WZLCodeLibrary[38748:3170794] member method:dealloc

2015-03-17 17:02:33.344 WZLCodeLibrary[38748:3170794] member method:init

复制代码

Method：runtime声明的一个宏，表示一个方法，typedef struct objc_method *Method;

class_copyMethodList：获取所有方法

method_getName：读取一个Method类型的变量，输出我们在上层中很熟悉的SEL

=========

接下来我们试着添加新的方法试试(这种方法等价于对Father类添加Category对方法进行扩展)：

复制代码

- (void)tryAddingFunction

{

class_addMethod([Father class], @selector(method::), (IMP)myAddingFunction, "i@:i@");

}

//具体的实现，即IMP所指向的方法

int myAddingFunction(id self, SEL _cmd, int var1, NSString *str)

{

NSLog(@"I am added funciton");

return 10;

}

复制代码

- (void)tryMemberFunc

{

//动态添加方法

[self tryAddingFunction];

count = 0;

memberFuncs = class_copyMethodList([Father class], &count);//所有在.m文件显式实现的方法都会被找到

for (int i = 0; i < count; i++) {

SEL name = method_getName(memberFuncs[i]);

NSString *methodName = [NSString stringWithCString:sel_getName(name) encoding:NSUTF8StringEncoding];

NSLog(@"member method:%@", methodName);

}

//尝试调用新增的方法

Father *father = [[Father alloc] init];

[father method:10 :@"111"];//当你敲入father实例后，是无法获得method的提示的，只能靠手敲。而且编译器会给出"-method" not found的警告，可以忽略

[father release];

}

复制代码

输出结果：

复制代码

2015-03-17 17:02:33.345 WZLCodeLibrary[38748:3170794] member method:method::

2015-03-17 17:02:33.345 WZLCodeLibrary[38748:3170794] member method:setAge:

2015-03-17 17:02:33.345 WZLCodeLibrary[38748:3170794] member method:age

2015-03-17 17:02:33.345 WZLCodeLibrary[38748:3170794] member method:sayHello

2015-03-17 17:02:33.345 WZLCodeLibrary[38748:3170794] member method:sayGoodbay

2015-03-17 17:02:33.345 WZLCodeLibrary[38748:3170794] member method:description

2015-03-17 17:02:33.346 WZLCodeLibrary[38748:3170794] member method:dealloc

2015-03-17 17:02:33.346 WZLCodeLibrary[38748:3170794] member method:init

复制代码

我们可以看到，method::方法的确被添加进类中了。有童鞋会问，如果在其他类文件中实例化Father类，还能调用到-method方法吗？答案是可以的，我试验过，在MRC下尽管无法获得代码提示，但请坚定不移地敲入[father method:xx :xx]方法！(在ARC下会报no visible @interface 错误)

接下来，我们拿系统函数玩玩，目标是让NSString函数的大小写转换功能对调，让APPLE乱套：

复制代码

- (void)tryMethodExchange

{

Method method1 = class_getInstanceMethod([NSString class], @selector(lowercaseString));

Method method2 = class_getInstanceMethod([NSString class], @selector(uppercaseString));

method_exchangeImplementations(method1, method2);

NSLog(@"lowcase of WENG zilin:%@", [@"WENG zilin" lowercaseString]);

NSLog(@"uppercase of WENG zilin:%@", [@"WENG zilin" uppercaseString]);

}

复制代码

输出结果：

2015-03-17 17:20:16.073 WZLCodeLibrary[38861:3180978] lowcase of WENG zilin:WENG ZILIN

2015-03-17 17:20:16.290 WZLCodeLibrary[38861:3180978] uppercase of WENG zilin:weng zilin

我们可以看到，结果乱套了！

私有函数控制还有其他多种玩法，这里就不一一举例了，算是抛砖引玉吧！

//可能遇到的问题

二楼，只需要把你调用[father method:10 :@"111"]的文件，再Build Phases----Compile Sources中把文件双击写入“-fno-objc-arc”，这样就修改成ARC\MRC混合开发了。再试试就不会报错了，只是警告。

Cola可乐

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
runloop和runtime的区别

一.RunLoop: Runloop是事件接收和分发机制的一个实现。 Runloop提供了一种异步执行代码的机制，不能并行执行任务。在主队列中，Main RunLoop直接配合任务的执行，负责处理UI事件、定时器以及其他内核相关事件。(1).RunLoop的主要目的：
复制链接

扫一扫