将Objective-C代码转换为C\C++代码
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc OC源文件 -o 输出的CPP文件
如果需要链接其他框架，使用-framework参数。比如-framework UIKit
Block
- block本质是一个OC对象，内部也有isa指针
- block是封装了函数调用，以及调用环境的OC对象
static struct __main_block_desc_0 {
size_t reserved;
size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int age;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _age, int flags=0) : age(_age) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
int main(int argc, char * argv[])
{
int age = 10;
void (*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, age));
age = 20;
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
}
为了保证block内部能够正常访问外部的变量，block有个变量捕获机制
变量捕获机制
当block内部访问了对象类型的auto变量时
如果block是在栈上，将不会对auto变量产生强引用
如果block被拷贝到堆上
会调用block内部的copy函数
copy函数内部会调用_Block_object_assign函数
_Block_object_assign函数会根据auto变量的修饰符（__strong、__weak、__unsafe_unretained）做出相应的操作，形成强引用（retain）或者弱引用
如果block从堆上移除
会调用block内部的dispose函数
dispose函数内部会调用_Block_object_dispose函数
_Block_object_dispose函数会自动释放引用的auto变量（release）
__block本质
__block可以用于解决block内部无法修改auto变量值的问题
__block不能修饰全局变量、静态变量（static）
编译器会将__block变量包装成一个对象
struct __Block_byref_age_0 {
void *__isa;
__Block_byref_age_0 *__forwarding;
int __flags;
int __size;
int age;
};
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__Block_byref_age_0 *age; // by ref
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_age_0 *_age, int flags=0) : age(_age->__forwarding) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
int main(int argc, char * argv[])
{
__block int age = 10;
void (^block)(void) = ^(){
age = 20;
};
block();
}
super
super消息机制,通过super调用的方法，最终都会转成objc_msgSendSuper(arg, SEL)
- arg: 为objc_super结构体，(struct objc_super){receiver,superclass}，结构体有两个成员，一个是消息接收者，一个是消息接收者的父类,superclass用于直接定位哪个父类的方法
- SEL：方法
：
@interface YCTest : NSObject
@end
@implementation YCTest
- (instancetype)init {
if (self = [super init]) {
NSLog(@"[self class] = %@",[self class]); // YCTest
NSLog(@"[super class] = %@",[super class]); // YCTest
NSLog(@"[self superclass] = %@",[self superclass]); // NSObject
NSLog(@"[super superclass] = %@",[super superclass]); // NSObject
}
}
@end
解释：
[self class]、[self superclass]都没问题,重点讲一下[super class]、[super superclass]
首先[super class]编译后会转换成objc_msgSendSuper( {self,class_getSuperclass(self)} , sel_registername("class") )，然后看一下class方法的实现:
//objc源码
+ (Class)class {
return self;
}
- (Class)class {
return objc_getClass(self);
}
+ (Class)superclass {
return self->superclass;
}
- (Class)superclass {
return [self class]->superclass;
}
可以看出都是传的self对象，也就是objc_super结构体的receiver成员
isKindofClass、isMemberOfClass
//objc源码
+ (BOOL)isMemberOfClass:(Class)cls {
return object_getClass((id)self) == cls;
}
- (BOOL)isMemberOfClass:(Class)cls {
return [self class] == cls;
}
+ (BOOL)isKindOfClass:(Class)cls {
for (Class tcls = object_getClass((id)self), tcls; tcls = tcls->superclass){
if (tcls == cls) return YES;
}
return NO;
}
- (BOOL)isKindOfClass:(Class)cls {
for (Class tcls = [self class], tcls; tcls = tcls->superclass){
if (tcls == cls) return YES;
}
return NO;
}
测试题：
@implementation YCViewController
- (void)viewDidLoad{
NSLog(@"%d",[self class] == [YCViewController class]);
NSLog(@"%d",[self class] == object_getClass(self));
NSLog(@"%d",[self class] == [[YCViewController class] class]);
NSLog(@"%d",[self class] == object_getClass(object_getClass(self)));
NSLog(@"%d",[[self class] class] == object_getClass(object_getClass(self)));
NSLog(@"%d",[self isMemberOfClass:[YCViewController class]]);
NSLog(@"%d",[[self class] isMemberOfClass:[YCViewController class]]);
NSLog(@"%d",[[self class] isMemberOfClass:object_getClass([YCViewController class])]);
NSLog(@"%d",[self isKindOfClass:[YCViewController class]]);
NSLog(@"%d",[self isKindOfClass:[NSObject class]]);
NSLog(@"%d",[[self class] isKindOfClass:[YCViewController class]]);
NSLog(@"%d",[[self class] isKindOfClass:object_getClass([YCViewController class])]);
NSLog(@"%d",[[self class] isKindOfClass:object_getClass([NSObject class])]);
//****格外注意***
NSLog(@"%d",[YCViewController isKindOfClass:[NSObject class]]);
}
//答案
/*
1
1
1
0
0
1
0
1
1
1
0
1
1
//****格外注意***
1
*/
@end
// 面试题
@interface YCObject ()
@property (nonatomic,copy) NSString *name;
@end
@implementation YCObject
- (void)print {
NSLog(@"my name is %@",self.name);
}
@end
- (void)viewDidLoad {
[super viewDidLoad];
NSString *test = @"123";
id cls = [YCObject class];
void *obj = &cls;
[(__bridge id)obj print];
}
- 解释
cls 指向YCObject类对象,相当于YCObject实例对象的isa指针，obj指针指向cls,obj相当于实例对象的指针。即:
YCObject *ycObj = [YCObject new];
ycObj->isa == cls // cls == YCObject实例对象isa
ycObj == obj
等同于：
obj->cls->[ YCObject class]
ycObj->isa->[ YCObject class]
因此：
[(__bridge id)obj print];
等同于：
[ycObj print];
再考虑到函数调用栈中局部变量的分配，是从高往低分配，所以上面viewDidLoad方法中，
从高到低变量的分配依次是：test >> cls >> obj，都是指针类型变量，因此每个变量占用8个字节。
再结合YCObject的print方法中调用到局部变量name,实例对象的内存布局前8个字节是isa指针，因此
实例对象偏移8个字节才能拿到name变量，所以再viewDidLoad方法上下文环境中，obj偏移8个字节即是
test字符串，因此打印输出为“my name is 123”
注意
如果注释掉“NSString *test = @"123";”，则输出为“my name is YCViewController<....>”,
原因是受到“[super viewDidLoad];”方法影响，这句话会调用objc_msgSendSuper方法，此方法第一个参数为结构体，结构体第一个参数为self
Runloop
runloop 与线程是一一对应关系，线程中默认是没有runloop的，只会在线程第一次获取runloop的时候才会创建runloop,且如果runloop没有一个mode的话，runloop会立马结束
typedef struct __CFRunLoop * CFRunLoopRef;
struct __CFRunLoop {
pthread_t _pthred;
CFMutableSetRef _commonModes; // 支持commonMode的runloopMode,如defaultMode,UITrackingMode
CFMutableSetRef _commonModeItems; // 设置了commonMode的timer，source
CFRunLoopModeRef _currentMode;
CFMutableSetRef _modes;
}
typedef struct __CFRunLoopMode *CFRunLoopModeRef;
struct __CFRunLoopMode {
CFStringRef _name;
CFMutableSetRef _sources0;
CFMutableSetRef _sources1;
CFMutableArrayRef _observers;
CFMutableArrayRef _timers;
}
Runloop 休眠实现原理：应用程序在用户态下发送mach_msg()消息，操作系统切换到内核态调用系统休眠，等待消息，有消息就切换回用户态处理消息，没有就继续休眠
Runloop使用场景：
- 控制线程生命周期（线程保活）
- NSTimer滑动时停止工作问题
- 监测应用卡顿
多线程
多线程方案有如下几种
多线程方案
判断以下代码是否会产生线程死锁
// 1
dispatch_sync(dispatch_get_main_queue(), ^{
NSLog(@"打印");
});
// 2
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
dispatch_async(queue, ^{
dispatch_sync(queue, ^{
NSLog(@"打印");
});
});
结论为都会产生死锁
线程死锁总结：使用sync 往 当前串行队列添加任务，会产生死锁
判断以下代码输出结果
- (void)test {
NSLog(@"2");
}
dispatch_async(dispatch_get_global_queue(0, 0), ^{
NSLog(@"1");
[self performSelector:@selector(test) withObject:nil afterDelay:.0];
NSLog(@"3");
});
// 1
// 3
因为performSelector:withObject:afterDelay:方法本质是添加了一个NSTimer定时器，并将定时器添加到当前runloop中，但是当前线程是没有保活的，也就是执行完NSLog(@"3")，线程就挂掉了，虽然afterDelay设置为.0,但也是个延迟操作，需要在下一个runloop生命周期才能生效，因此需要设置runloop的一个运行时长
- (void)test {
NSLog(@"2");
}
dispatch_async(dispatch_get_global_queue(0, 0), ^{
NSLog(@"1");
[self performSelector:@selector(test) withObject:nil afterDelay:.0];
NSLog(@"3");
// 需要注意以下代码添加位置，因为runMode:beforeDate:是开启了一个一定时长的循环，也就是在这时间内都是循环在当前位置，runMode:beforeDate:方法后面的代码将不会执行到
[[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];
});
多线程加锁
多线程一般需要考虑线程同步问题，以及防止死锁(一些递归调用，嵌套调用会导致死锁，还有同步主队列任务也会死锁)。还有某些依赖条件下，锁的问题，如增删操作，当删除操作的线程先加锁，但是此时无数据可删，此时需要条件等待(如pthread_cond_wait()此操作会将当前线程休眠，放开锁，被唤醒后会再次加锁，与pthread_cond_signal()配对使用，signal是激活一个等待该条件的线程)
- OSSpinLock:
- 自旋锁，加锁的地方会忙等，一直占用CPU资源，直到锁放开。此方法存在优先级反转问题，即如果优先级低的线程先加锁，然后优先级高的线程会忙等，但是由于优先级高的线程分配的资源更多，会存在优先级的线程资源不足而无法继续执行，此时互相等待，就造成死锁状态。
- os_unfair_lock
- 用于替代OSSpinLock，等待锁的线程处于休眠状态而不是忙等。
- pthread_mutex
- 互斥锁，等待锁的线程休眠，可以设置递归锁，以及条件等待
- NSLock
- 对pthread_mutex的封装
- NSRecursiveLock
- 对pthread_mutex的封装,递归锁
- NSCondition
- 对mutex和cond的封装
- NSConditionLock
- 对NSCondition的进一步封装
- dispatch_semaphore
- 控制线程并发访问的最大数量
iOS内存布局
iOS内存布局
Tagged Pointer
如何判断一个指针是否为Tagged Pointer？
iOS平台，最高有效位是1（第64bit）
Mac平台，最低有效位是1
// 判断下列两个方法是否能正常运行，结果是否一致
dispatch_async(dispatch_get_global_queue(0, 0), ^{
for (NSInteger i = 0; i < 1000; i++) {
self.name = [NSString stringWithFormat:@"abcdefghijklmn"];
}
});
dispatch_async(dispatch_get_global_queue(0, 0), ^{
for (NSInteger i = 0; i < 1000; i++) {
self.name = [NSString stringWithFormat:@"abc"];
}
});
// 结论
此处需要结合ARC下set方法的底层实现，以及Tagged Pointer技术
- (void)setName:(NSString *)name {
if (_name != name) {
[_name release];
_name = [name copy];
}
}
可以看到，在多线程情况下，如果同时调用[_name release];方法，则会导致过度释放问题，导致坏内存访问。
至于@“abc”字符串，因为其使用的是Tagged Pointer技术，也就是直接存储在地址中，赋值操作是直接地址赋值
dealloc实现
内部会调用rootDealloc(), 此方法内部判断当前对象是否是taggedPointer, 根据isa判断是否是nonpointer、weakly_referenced、has_assoc、has_cxx_dtor、has_sidetable_rc，如果是就走快速释放，否则调用object_dispose()方法，此方法内部调用objc_destructInstance()方法，然后调用C函数free()
objc_destructInstance()方法内部，清除成员变量，移除关联对象，调用当前对象的clearDeallocating()方法，将指向当前对象的弱指针置为nil,弱指针存在SideTables这个哈希表中
ARC
ARC是LLVM+Runtime相互协作的结果，利用LLVM编译器自动在代码合适的位置添加release或autorelease, 利用runtime在对象释放的时候将弱引用置空
持续更新中......