开局几道面试题：
- 使用CADisplayLink、NSTimer有什么注意点
- 介绍下内存的几大区域
- 讲一下你对iOS内存管理的理解
- ARC帮我们做了什么？
- weak指针的实现原理
- autorelease对象在什么时机会被调用release
- 方法里面有局部变量，出了方法后会立即释放吗？
小伙伴，你能答出几道？有哪些是不太了解的？通过下面的学习，你讲掌握以上面试题。
CADisplayLink、NSTimer使用注意
CADisplayLink、NSTimer会对Target产生强引用，如果target又对他们产生强引用，那么就会引发循环引用。
举一个栗子：
@interface ViewController ()
@property (strong, nonatomic) NSTimer *timer;
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
//__weak typeof(self) weakSelf = self;
self.timer = [NSTimer scheduledTimerWithTimeInterval:1.0 target:self selector:@selector(test) userInfo:nil repeats:YES];
}
- (void)test
{
NSLog(@"子线程需要做的操作--%s, %@", __func__, [NSThread currentThread]);
}
- (void)dealloc
{
[self.timer invalidate];
NSLog(@"%s", __func__);
}
这样使用NSTimer会产生循环引用问题。
这是因为：
控制器强引用了timer：
@property (strong, nonatomic) NSTimer *timer;
而timer会对target对象，也就是self(控制器)产生强引用。
因此，造成循环引用。
__weak typeof(self) weakSelf = self;能否解决NSTimer的循环引用问题？
答：我们并不能够通过__weak typeof(self) weakSelf = self;代码来实现解决循环引用。
__weak typeof(self) weakSelf = self;是用在block内可以解决循环引用的问题。
当
self.block = ^{
self.name = @"jack";
}
block内部使用self，block会对self产生强引用。
当
__weak typeof(self) weakSelf = self;
self.block = ^{
weakSelf.name = @"jack";
}
block内部使用weakSelf，由于weakSelf是__weak修饰，因此，block会对weakSelf产生弱引用。
归根到底，是block对外部变量的引用是强或弱是由__weak改变。
首先，我们要知道，weakSelf与self虽然属于存储在不同的地方，但是其指向的同一个内存地址。
在我们使用NSTimer的时候，有一个问题是，timer拥有target是强引用，而不管该target是强或者弱指针引用。
所以，也就有了下图：
不管target本身是self，或者是weakSelf，NSTimer对target都是强引用。
也就是，外面传进去的target参数值类型是强或者弱，对内部强引用没有改变。
解决NSTimer循环引用方法一：使用block
使用block
__weak typeof(self) weakSelf = self;
self.timer = [NSTimer scheduledTimerWithTimeInterval:1.0 repeats:YES block:^(NSTimer * _Nonnull timer) {
[weakSelf test];
}];
解决NSTimer循环引用方法二：使用中间变量
基本上逻辑就是这样：
如何实现
举个例子：
@interface YZMiddleTarget : NSObject
@property (weak, nonatomic) id target;
+ (instancetype)middleTargetWithTarget:(id)target;
@end
#import "YZMiddleTarget.h"
@implementation YZMiddleTarget
+ (instancetype)middleTargetWithTarget:(id)target
{
YZMiddleTarget *middleTarget = [[YZMiddleTarget alloc] init];
middleTarget.target = target;
return middleTarget;
}
//消息转发
- (id)forwardingTargetForSelector:(SEL)aSelector
{
return self.target;//返回可以处理的对象
}
@end
使用：
self.timer = [NSTimer scheduledTimerWithTimeInterval:1.0 target:[YZMiddleTarget middleTargetWithTarget:self] selector:@selector(test) userInfo:nil repeats:YES];
解决NSTimer循环引用方法三：viewWillDisappear
- (void)viewWillDisappear:(BOOL)animated{
[super viewWillDisappear:animated];
[self.timer invalidate];
self.timer = nil;
}
CADisplayLink使用
CADisplayLink没有block调用方法，因此，在解决循环引用的问题 上，可以使用中间变量或者viewWillDisappear
@property (strong, nonatomic) CADisplayLink *link;
{
//CADisplayLink不需要设置时间，调用频率和屏幕刷侦频率一样，大概是60FPS。也就是一秒钟调用60次。如果线程任务量大，可能一秒就没有60次。
self.link = [CADisplayLink displayLinkWithTarget:[YZMiddleTarget middleTargetWithTarget:self] selector:@selector(test)];
[self.link addToRunLoop:[NSRunLoop currentRunLoop] forMode:NSDefaultRunLoopMode];
}
- (void)dealloc
{
[self.link invalidate];
NSLog(@"%s", __func__);
}
NSProxy学习
proxy:代理
首先，我们看下NSObject与NSProxy的声明：
NSObject的声明：
@interface NSObject <NSObject> {
Class isa OBJC_ISA_AVAILABILITY;
}
NSProxy的声明：
@interface NSProxy <NSObject> {
Class isa;
}
可以看出NSObject和NSProxy都是基类
当我们使用继承NSObject的YZMiddleTarget时，不实现消息转发
self.timer = [NSTimer scheduledTimerWithTimeInterval:1.0 target:[YZMiddleTarget middleTargetWithTarget:self] selector:@selector(test) userInfo:nil repeats:YES];
@implementation YZMiddleTarget
+ (instancetype)middleTargetWithTarget:(id)target
{
YZMiddleTarget *middleTarget = [[YZMiddleTarget alloc] init];
middleTarget.target = target;
return middleTarget;
}
@end
报错类型是:
当我们使用继承NSProxy的YZProxy时，不实现消息转发
self.timer = [NSTimer scheduledTimerWithTimeInterval:1.0 target:[YZProxy middleTargetWithTarget:self] selector:@selector(test) userInfo:nil repeats:YES];
@implementation YZMiddleTarget
+ (instancetype)middleTargetWithTarget:(id)target
{
YZMiddleTarget *middleTarget = [[YZMiddleTarget alloc] init];
middleTarget.target = target;
return middleTarget;
}
@end
reason: '*** -[NSProxy methodSignatureForSelector:] called!'
可以看出，两个的报错提示不一样。
原因，就是NSProxy调用，找不到方法的时候，就直接调用消息转发里面的方法签名：
- (nullable NSMethodSignature *)methodSignatureForSelector:(SEL)sel NS_SWIFT_UNAVAILABLE("NSInvocation and related APIs not available");
- (void)forwardInvocation:(NSInvocation *)invocation;
也没有走消息转发里面的- (id)forwardingTargetForSelector:(SEL)aSelector;方法
使用YZProxy解决消息转发问题：
@implementation YZProxy
+ (instancetype)middleTargetWithTarget:(id)target
{
//NSProxy没有init方法
YZProxy *middleTarget = [YZProxy alloc];
middleTarget.target = target;
return middleTarget;
}
- (NSMethodSignature *)methodSignatureForSelector:(SEL)sel
{
return [self.target methodSignatureForSelector:sel];
}
- (void)forwardInvocation:(NSInvocation *)invocation
{
[invocation invokeWithTarget:self.target];
}
@end
NSObject的消息机制，请看Runtime的本质(三)----objc_msgSend;
NSProxy专门做消息转发，有调用的方法就直接调用。如果没有这个方法的话，直接就到消息转发阶段，没有去父类查找或者缓存中查找的过程，更有效率。
proxy的一个神奇的现象:
看到没，proxy居然是属于YZPerson的一个子类。
这是因为，在调用[proxy isKindOfClass:[YZPerson class]]的时候，内部已经不是proxy，而是person。
该person是[YZProxy middleTargetWithTarget:person];方法传进去的，也就是通过消息转发，将target为proxy变为peron。
结合GUNStep中的NSProxy源码，可以看到：
NSProxy的isKindOfClass方法直接执行了消息转发的方法。
NSProxy还真是不能按常理思考，能用、慎用。
CADisplayLink、NSTimer是基于RunLoop机制的，如果RunLoop的任务过于繁重，有可能会导致前两个定时器不准时。
举个例子：
加入我们创建了一个NSTimer定时器，每1秒钟做任务。那么，什么时候执行NSTimer呢？
是在RunLoop跑圈的过程中执行NSTimer定时器，而RunLoop跑完一圈执行的时间不固定，也就导致有可能1秒钟过去了，但是RunLoop还没有执行到定时器的任务，那么，这就造成定时器有可能不准时。
因此，我们引出GCD的定时器。
GCD定时器
GCD是不依赖与RunLoop，是直接跟系统内核交互的。
GCD定时器的使用方法：
当然，我们可以封装一下，以后就更好使用：
#import <Foundation/Foundation.h>
NS_ASSUME_NONNULL_BEGIN
@interface YZGCDTimer : NSObject
+ (NSString *)timerWithBlockTask:(void(^)(void))blockTask
star:(float)star
interval:(float)interval
repeat:(BOOL)repeat
async:(BOOL)async;
+ (void)cancelTask:(NSString *)name;
@end
#import "YZGCDTimer.h"
@implementation YZGCDTimer
static NSMutableDictionary *timersDict;
static dispatch_semaphore_t semaphore;
+ (void)initialize
{
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
timersDict = [NSMutableDictionary dictionary];
semaphore = dispatch_semaphore_create(1);//创建一个信号量，只允许一个线程操作
});
}
+ (NSString *)timerWithBlockTask:(void (^)(void))blockTask star:(float)star interval:(float)interval repeat:(BOOL)repeat async:(BOOL)async
{
if (!blockTask || star<0 || (repeat && interval <= 0)) return nil;
//创建队列，队列决定到时候任务是在哪个线程执行
dispatch_queue_t queue = async ? dispatch_queue_create("myQueue", DISPATCH_QUEUE_SERIAL) : dispatch_get_main_queue();
//创建一个定时器
dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
/**
dispatch_source_set_timer 上面的定时器
dispatch_time_t start 开始时间 (typedef uint64_t dispatch_time_t;)
uint64_t interval 间隔
uint64_t leeway 误差一般写0
*/
dispatch_source_set_timer(timer, dispatch_time(DISPATCH_TIME_NOW, star * NSEC_PER_SEC), interval *NSEC_PER_SEC, 0);
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);//信号量
//定时器唯一标识
static int i = 0;
NSString *name = [NSString stringWithFormat:@"%d", i++];
//放进字典，就会产生强引用
timersDict[name] = timer;
dispatch_semaphore_signal(semaphore);
//设置回调
dispatch_source_set_event_handler(timer, ^{
blockTask();
if (!repeat) {//如果非重复执行
[self cancelTask:name];//取消定时器
}
});
//启动定时器
dispatch_resume(timer);
//GCD不需要销毁
return name;
}
+ (void)cancelTask:(NSString *)name
{
if (name.length == 0) return;
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
dispatch_source_t timer = timersDict[name];
if (!timer) return;
dispatch_source_cancel(timer);
[timersDict removeObjectForKey:name];
dispatch_semaphore_signal(semaphore);
}
@end
使用：
#import "YZGCDTimer.h"
@interface ViewController ()
@property (copy, nonatomic) NSString *task;
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
self.task = [YZGCDTimer timerWithBlockTask:^{
NSLog(@"执行任务---%@", [NSThread currentThread]);
} star:2.0 interval:1.0 repeat:YES async:YES];
}
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
[YZGCDTimer cancelTask:self.task];
}
@end
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
