- @synthesize
@interface Test : NSObject
@property (nonatomic, strong) NSString *name;
@end
@implementation Test
// 使用必须先有@property
// @synthesize name; == @synthesize name = name;
// 会自动生成setter getter方法声明和实现（可以都重写） 并且生成对应的成员变量，成员变量名就是后面的名字
// 像下面这么写的话，默认的_name成员变量就变成了syn_name，通过self.name或syn_name来访问
// 如果遵循的协议内部有property，就要用@synthesize
@synthesize name = syn_name;
- (void)setName:(NSString *)name {
syn_name = name;
}
- (NSString *)name {
return syn_name;
}
@end
- @dynamic
@interface Test : NSObject {
NSInteger _dynamic_height
}
@property (nonatomic, assign) NSInteger height;
@end
@implementation Test
// 使用必须先有@property
// 告诉编译器不要生成成员变量，也不要生成setter，getter的实现，但是setter getter的方法声明还是有
// 如果直接调用test.height = x 会报方法找不到
// 一般会再写一个成员变量，然后实现setter getter方法 ，如_dynamic_height
// 不加成员变量也可以，实现方法就行
@dynamic height;
- (void)setHeight:(NSInteger)height {
_dynamic_height = height;
}
- (NSInteger)height {
return _dynamic_height;
}
@end
- @property
@property (nonatomic, assign) NSInteger height;
// 等同于@synthesize height = _height; 属性是用来描述成员变量在当前类中的特征
- nonatomic & atomic
// 源码层面的区别
StripedMap PropertyLocks;
StripedMap StructLocks;
StripedMap CppObjectLocks;
#define MUTABLE_COPY 2
id objc_getProperty(id self, SEL _cmd, ptrdiff_t offset, BOOL atomic) {
if (offset == 0) {
return object_getClass(self);
}
// Retain release world
id *slot = (id*) ((char*)self + offset);
if (!atomic) return *slot;
// Atomic retain release world
spinlock_t& slotlock = PropertyLocks[slot];
slotlock.lock();
id value = objc_retain(*slot);
slotlock.unlock();
// for performance, we (safely) issue the autorelease OUTSIDE of the spinlock.
return objc_autoreleaseReturnValue(value);
}
static inline void reallySetProperty(id self, SEL _cmd, id newValue, ptrdiff_t offset, bool atomic, bool copy, bool mutableCopy) __attribute__((always_inline));
static inline void reallySetProperty(id self, SEL _cmd, id newValue, ptrdiff_t offset, bool atomic, bool copy, bool mutableCopy)
{
if (offset == 0) {
object_setClass(self, newValue);
return;
}
id oldValue;
id *slot = (id*) ((char*)self + offset);
if (copy) {
newValue = [newValue copyWithZone:nil];
} else if (mutableCopy) {
newValue = [newValue mutableCopyWithZone:nil];
} else {
if (*slot == newValue) return;
newValue = objc_retain(newValue);
}
if (!atomic) {
oldValue = *slot;
*slot = newValue;
} else {
spinlock_t& slotlock = PropertyLocks[slot];
slotlock.lock();
oldValue = *slot;
*slot = newValue;
slotlock.unlock();
}
objc_release(oldValue);
}
示例：
@interface Cat : NSObject
@property (nonatomic, copy) NSString *name;
@end
// 默认cat.name = @"001"
@interface Person : NSObject
@property (nonatomic, strong) Cat *cat;
@end
1.threadA => 读取cat.name
2.threadB => person.cat = Cat(@"002")
3.threadC => person.cat = Cat(@"003")
Q:threadA会读取到什么值？
Q:最后cat会是哪一个？
atomic:
1.读取到的值有三种可能:"001"，"002"，"003"
2."002", "003"nonatomic:
1.读取到的值可能是"001"，"002"，"003"或者报错，why？
2."002", "003"
set方法伪代码:
- (void)setCat:(Cat *)cat {
if (_cat != cat) {
// 1
[_cat release];
// 2
_cat = [cat retain];
// 3
}
}
在多线程环境中时，如果threadA读取值的时候，threadB刚好执行到2，那么就有可能报错。
nonatomic atomic两者最大的区别就是atomic在操作的时候加了一个自旋锁，使得同一时间只有一个线程能访问setter/getter。但是这只能保证setter getter操作是完整的（指操作要么完成，要么失败），并且返回一个有效的值（即操作原子性）。
在很多时候，多线程竞争同一资源，仅靠atomic是远远不够的，所以会采用其他的措施，如加锁，信号量，串行队列等，iOS上资源比较宝贵，所以推荐使用nonatomic，MacOS上就随意了。
- 内存管理关键字
strong：ARC时代用来取代retain，默认局部变量、成员变量都是strong 对象引用计数会+1，持有对象
weak：弱引用，不持有对象，不会增加对象的引用计数，当指向的对象dealloc的时候会自动置为nil，只能用于对象类型
assign：同weak，但是assign不会置空，可能会有野指针的存在，且assign可用于基本类型如 int float NSInteger等，因为基本类型都是在栈空间由系统来管理内存，所以用assign
retain：持有对象 引用计数+1
copy：setter时，对新值进行copy，如果生成了新对象，那么原来对象的引用计数不会变，没有生成新对象，那被copy对象引用计数+1。对象要遵守NSCopying协议，较多用在NSArray NSString上
unsafe_unretained：有些类不支持weak修饰就用这个
- 默认值
@property NSString *name;
@property NSInteger age;
//等同于
@property (atomic, strong, readwrite) NSString *name;
@property (atomic, assign, readwrite) NSInteger age;
// 对象类型 就是strong 基本类型就是assign
- 如果同时重写setter和getter
编译器会报错，它觉得你也不想要这个成员变量了，加上@synthesize xxx 即可解决