CADisplayLink、NSTimer使用注意
CADisplayLink、NSTimer会对target产生强引用，如果target又对它们产生强引用，那么就会引发循环引用；其次，NSTimer有时候不准。
CADisplayLink解决方案
使用代理对象（NSProxy）
NSTimer解决方案
使用block
使用代理对象（NSProxy）
CADisplayLink
可以认为是一个定时器，这个定时器特殊在不用设置时间，同时又保证调用频率和屏幕的刷帧频率一致，60FPS，会循环引用。
//初始化CADisplayLink
CADisplayLink *link = [CADisplayLink displayLinkWithTarget:[MJProxy proxyWithTarget:self] selector:@selector(linkTest)];
//加入运行循环，开始工作
[link addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSDefaultRunLoopMode];
上述代码会引起循环引用，控制器销毁后这个CADisplayLink仍然继续工作。
NSTimer
//NSTimer也会产生循环引用
self.timer = [NSTimer scheduledTimerWithTimeInterval:1.0 target:self selector:@selector(timerTest) userInfo:nil repeats:YES];
针对上面循环引用，可能想为啥不用__weak typeof(self) weakSelf = self;声明后然后weakSelf替代self,即使替代也没有用，原因有二，一：weakSelf在block内部有作用是因为block会根据强弱进行内部的强弱引用而已；二：即使把weakSelf传给上述方法，上述方法内部进行接收的局部参数依旧是强引用。
CADisplayLink、NSTimer循环引用原因：对象里面的target引用self，self引用对象，导致双方都无法释放。
解决CADisplayLink循环引用的方法
// 找个中间对象 解决了循环引用
//原理就是：控制器里的link指针强引用CADisplayLink，CADisplayLink对象里的target强引用中间对象，中间对象里的target弱引用引用控制器。这样当控制器销毁时整个链就解开了。
self.link = [CADisplayLink displayLinkWithTarget:[MJProxy proxyWithTarget:self] selector:@selector(linkTest)];
[self.link addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSDefaultRunLoopMode];
解决NSTimer循环引用的方法
第一种解决NSTimer循环引用方法
__weak typeof(self) weakSelf = self;
self.timer = [NSTimer scheduledTimerWithTimeInterval:1.0 repeats:YES block:^(NSTimer * _Nonnull timer) {
[weakSelf timerTest];
}];
第二种解决NSTimer循环引用方法,找一个中间对象，实现中间对象的部分弱引用。
self.timer = [NSTimer scheduledTimerWithTimeInterval:1.0 target:[MJProxy proxyWithTarget:self] selector:@selector(timerTest) userInfo:nil repeats:YES];
NSProxy
直接就是像NSObject一样是基类
NSProxy设计初衷用来做中间类做消息转发,效率高。(ps:MJ说因为在调一个不存在的方法时，直接触发消息转发方法经测试是错的，还是会走动态方法解析阶段）
下面设计一个中间转发类
.h文件
#import <Foundation/Foundation.h>
//注意这里继承于NSProxy类,NSProxy设计初衷用来做中间类做消息转发,效率高
@interface MJProxy : NSProxy
+ (instancetype)proxyWithTarget:(id)target;
@property (weak, nonatomic) id target;//注意这是弱引用
@end
.m文件
#import "MJProxy.h"
@implementation MJProxy
+ (instancetype)proxyWithTarget:(id)target
{
// NSProxy对象不需要调用init，因为它本来就没有init方法
MJProxy *proxy = [MJProxy alloc];
proxy.target = target;
return proxy;
}
//这句也是实现下面两句的功能，不过forwardingTargetForSelector方法在NSProxy头文件里居然被注释，不知道为什么
//- (id)forwardingTargetForSelector:(SEL)aSelector
//{
// return self.target;
//}
//当外界调用方法没有而且动态解析以后来到这里
- (NSMethodSignature *)methodSignatureForSelector:(SEL)sel
{
return [self.target methodSignatureForSelector:sel];
}
- (void)forwardInvocation:(NSInvocation *)invocation
{
[invocation invokeWithTarget:self.target];
}
@end
// 下面是拿上面MJProxy继承NSProxy的实战，里面实现消息转发给ViewController。MJProxy1继承NSObject(里面代码和MJProxy一样，却别在于继承NSObject)。执行下面程序，可以看到[proxy isKindOfClass:[ViewController class]]居然是1，是因为isKindOfClass只在NSObject里有，所以proxy调isKindOfClass转发给了ViewController去调isKindOfClass
int main(int argc, char * argv[]) {
@autoreleasepool {
ViewController *vc = [[ViewController alloc] init];
MJProxy *proxy = [MJProxy proxyWithTarget:vc];
MJProxy1 *proxy1 = [MJProxy1 proxyWithTarget:vc];
NSLog(@"%d %d",
[proxy isKindOfClass:[ViewController class]], //打印为1
[proxy1 isKindOfClass:[ViewController class]]); //打印为0
return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
}
}
GCD定时器
NSTimer依赖于RunLoop，如果RunLoop的任务过于繁重，跑圈循环时间就不固定，或者受RunLoop模式的影响，都可能会导致NSTimer不准时
而GCD的定时器会更加准时
@interface ViewController ()
@property (strong, nonatomic) dispatch_source_t timer;
@end
- (void)viewDidLoad {
[super viewDidLoad];
//换成主队列只是为了验证GCD创建的定时器不受运行循环的mode影响，一般放在子线程
// dispatch_queue_t queue = dispatch_get_main_queue();
// 获得队列
dispatch_queue_t queue = dispatch_queue_create("timer", DISPATCH_QUEUE_SERIAL);
// 创建一个定时器(dispatch_source_t本质还是个OC对象)
dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
// 何时开始执行第一个任务
// dispatch_time(DISPATCH_TIME_NOW, 3.0 * NSEC_PER_SEC) 比当前时间晚3秒
dispatch_time_t start = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3.0 * NSEC_PER_SEC));
//每隔多长时间执行一次(1.0 * NSEC_PER_SEC，1秒执行一次)
uint64_t interval = (uint64_t)(1.0 * NSEC_PER_SEC);
// 设置定时器的各种属性（几时开始任务，每隔多长时间执行一次，最后一个参数是误差）
dispatch_source_set_timer(timer, start, interval, 0);
// 通过回调设置任务
// dispatch_source_set_event_handler(timer, ^{
// NSLog(@"1111");
// });
// 通过调用方法设置任务
dispatch_source_set_event_handler_f(timer, timerFire);
// 启动定时器
dispatch_resume(timer);
//self.timer全局对象，不然被释放没法运行timer
self.timer = timer;
}
void timerFire(void *param)
{
NSLog(@"2222 - %@", [NSThread currentThread]);
}
@end
然后又封装了一个公共类
#import <Foundation/Foundation.h>
@interface MJTimer : NSObject
+ (NSString *)execTask:(void(^)(void))task
start:(NSTimeInterval)start
interval:(NSTimeInterval)interval
repeats:(BOOL)repeats
async:(BOOL)async;
+ (NSString *)execTask:(id)target
selector:(SEL)selector
start:(NSTimeInterval)start
interval:(NSTimeInterval)interval
repeats:(BOOL)repeats
async:(BOOL)async;
+ (void)cancelTask:(NSString *)name;
@end
#import "MJTimer.h"
@implementation MJTimer
static NSMutableDictionary *timers_;
dispatch_semaphore_t semaphore_; //添加信号量的原因是避免多线程对全局的字典进行添加和删除操作出现数据错误问题，进而添加信号量，让添加和删除这两个操作串行。
+ (void)initialize
{
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
timers_ = [NSMutableDictionary dictionary];
semaphore_ = dispatch_semaphore_create(1);
});
}
+ (NSString *)execTask:(void (^)(void))task start:(NSTimeInterval)start interval:(NSTimeInterval)interval repeats:(BOOL)repeats async:(BOOL)async
{
if (!task || start < 0 || (interval <= 0 && repeats)) return nil;
// 队列
dispatch_queue_t queue = async ? dispatch_get_global_queue(0, 0) : dispatch_get_main_queue();
// 创建定时器
dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
// 设置时间
dispatch_source_set_timer(timer,
dispatch_time(DISPATCH_TIME_NOW, start * NSEC_PER_SEC),
interval * NSEC_PER_SEC, 0);
dispatch_semaphore_wait(semaphore_, DISPATCH_TIME_FOREVER);
// 定时器的唯一标识
NSString *name = [NSString stringWithFormat:@"%zd", timers_.count];
// 存放到字典中
timers_[name] = timer;
dispatch_semaphore_signal(semaphore_);
// 设置回调
dispatch_source_set_event_handler(timer, ^{
task();
if (!repeats) { // 不重复的任务
[self cancelTask:name];
}
});
// 启动定时器
dispatch_resume(timer);
return name;
}
+ (NSString *)execTask:(id)target selector:(SEL)selector start:(NSTimeInterval)start interval:(NSTimeInterval)interval repeats:(BOOL)repeats async:(BOOL)async
{
if (!target || !selector) return nil;
return [self execTask:^{
if ([target respondsToSelector:selector]) {
#pragma clang diagnostic push //强制消除警告
#pragma clang diagnostic ignored "-Warc-performSelector-leaks" //“”里是警告内容
[target performSelector:selector];
#pragma clang diagnostic pop
}
} start:start interval:interval repeats:repeats async:async];
}
+ (void)cancelTask:(NSString *)name
{
if (name.length == 0) return;
dispatch_semaphore_wait(semaphore_, DISPATCH_TIME_FOREVER);
dispatch_source_t timer = timers_[name];
if (timer) {
dispatch_source_cancel(timer);
[timers_ removeObjectForKey:name];
}
dispatch_semaphore_signal(semaphore_);
}
@end
网友评论