Please enable JavaScript.

Coggle requires JavaScript to display documents.

OC (OC 基础 (block (内存管理 (应用内存分配 (程序区域 .text 区数据区域 .data 区堆栈),…

- - - - stack
      - global
      - malloc
    - - block 自动变量变量
        
        全局变量
        全局静态变量
        局部变量 // 构造 block 的时候作为参数传入，相当于捕获当前的值到 block 结构体里面
        局部静态变量 //构造 block 的时候传入地址，所以也可以在 block 内部修改外部值
        
        block 变量
        被 block 修饰的变量会为该变量构建一个 struct
        
        原理
        
        struct __Block_byref_a_0 { void *__isa; // 如果 __block value 一般指向自己，但是如果 stack 复制到 malloc 那么会指向 stack block value-> __forwarding 指向 copy 的地址。 __Block_byref_a_0 *__forwarding; int __flags; int __size; int a; // 实际的值 }
      - 捕获对象变量
        
        对象在作用域之外的时候本来应该销毁的。
        例如：
        blk_t blk; { //注意没有使用__block id array = [NSMutableArray new]; blk = [^(id obj) { [array addObject: obj]; NSLog(@"array count = %ld", [array count]); } copy]; } blk([NSObject new]); blk([NSObject new]); blk([NSObject new]);
        array 本应该销毁了，大事blk 还是能顺利执行为什么
        
        __main_block_desc_0
        这个结构体会新增
        
        copy 相当于block 的 retain 栈上的 block 复制到堆时会调用
        
        dispose 相当于blokc 的 release 对上的 block 被销毁时调用
        方法
        
        上面两个方法里面分别执行了
        _Block_object_assign(&dst->array,src->array,BLOCK_FIELD_IS_OBJECT); _Block_object_dispose(src->array, BLOCK_FIELD_IS_OBJECT); 第二个参数 BLOCK_FIELD_OBJECT 和 BLOCK_FIELD_BYREF 分别对应对象和__block 自动变量。
        有了这种结构就可以通过使用 __strong 修饰自动变量，这样 block 截获的自动变量就可以超过作用域而存在
    - - block 本质是一个结构体
        结构体有一个函数指针，指向 block 内具体函数
        struct __main_block_impl_0 { struct __block_impl impl; struct __main_block_desc_0* Desc; __Block_byref_a_0 *a; // by ref 捕获的变量，初始化的时候传入 } struct __block_impl { void *isa; int Flags; int Reserved; void *FuncPtr; // 具体操作的方法 }
    - - 栈上定义的 block 储存在 stack
      - 全局区定义的 block 储存在数据区 .data 区
        另外没有捕获外部变量的 block 也是储存在 .data 区
      - 应用内存分配
        
        程序区域 .text 区
        
        数据区域 .data 区
        
        堆
        
        栈
      - 显示复制到堆空间
        
        使用 copy 可以将 stackBlock 显示复制到 malloc
        （对 block 进行 copy CPU开销比较大）
        
        隐式复制到堆空间
        
        block 作为返回值
        
        将 block 赋值给 __strong 修饰的 id 类型时或 block 类型的成员变量时
        
        GCD API
        
        带有 usingBlock 的接口
      - 当 block 使用 block 变量，如果 block 复制到堆空间， block 变量结构体也会复制到堆空间，如果多个 block 引用一个堆空间的__block 变量，引用计数会加一，知道没有block 引用该变量才释放
  - - - 可变的安全的，不可变的不安全的
        一般返回值 return [array copy]
        来返回一个不可变的线程安全对象
        
        例外 NSCache 使用可变的
        NSMutableDictory 储存不可变的数据
  - - - NSCopying
        
        copyWithZone
    - - NSMutableCopying
        
        mutableCopyWithZone
  - - - 不会奔溃为什么
        
        OC 函数调用通过 objc_msgSend 进行消息发送，如果 self 为 nil 那么 selector 也会为空，直接返回
- - - - 在自动释放池中重复调用 autoRelease 会报错，首个autorelease 已经成功释放，之后的就相当于在野指针上操作
      - autoRelease 的对象在什么时候释放，在所在 runloop 迭代结束的时候释放
    - - __weak
        
        持有的对象为释放后，会置为 nil
      - strong 默认符号
        id * 类型默认修饰为 autorelease
        
        id a = [NSObject new]; //等价于 id __strong a = [NSObject new]; id *a = [NSObject new];// 等价于 id __autorelease *a = [NSObject new];// 典型场景方法传 Error 对象地址
      - __unsafe_unretained
        
        持有的对象释放后，不会置为nil
        被它修饰的对象，不属于编译器内存管理对象
        在 ARC 的有效的情况下，不能在 C 的 struc 和 union 中添加成员对象，如果要添加我们可以在成员中使用 __unsafe_unretained 来进行修饰也可以强转为 void * (注意在 ARC 环境 id 对象直接给 void * 赋值会有问题) 需要使用 __bridge 修饰来强转 void *b = (__bridge void *)a; id a = (__bridge id)b;
        bridge_retained 复制动作完成后不释放（复制动作会 retain 一次） bridge_transfer 赋值动作完成后马上释放
      - __autoreleasing
        
        系统自带的类库中，哪些工厂方法返回的是 __autoreleasing 修饰的对象
        一般alloc/new/copy/mutableCopy 方法以外返回的是 __autoreleaesing 修饰的对象
      - 初始化，除了 __unsafe_retained 其他修饰符，初始化默认为 nil
    - - OC 对象和 C 对象互转
        
        CFBridgingRetain()
        
        __bridge_retained
        
        CFBridgingRelease()
        
        赋值给变量指针时，修饰符必须一致
        NSError *error = nil; NSError **perror = &error;// 错误，修饰符要一直使用 __strong
      - C 对象转 OC 对象
        
        数组
        
        静态数组
        
        使用 calloc 分配一个数组
        或者 malloc 然后 memset 为 0
        
        释放的时候 free(array)
        
        动态数组
        
        使用 calloc 分配一个数组
        
        释放的时候先要对数组内的元素置位 nil
        （即先释放数组内的元素）不然会内存泄露
        
        使用 memcpy 和 realloc 函数重新分配内存块也会有危险
        因为：
      - __bridge
        但是 bridge 本身不改变引用计数，所以还需要 bridge_retain 存疑
    - - 由 clang(LLVM) 和 OC 运行时库实现
      - id obj = [[NSObject alloc] init]
        
        objc_msgSend(obj,@selector(init)) objc_msgSend(objc_getClass("A"), sel_registerName("c"));
        用于调用对象、类的方法
      - id obj = [NSMutableArray array];
        
        id obj = objc_msgSend(NSMutableArray,@selector(array)); objc_retainAutoreleasedReturnValue(objc); //注意这个地方使用了autorelease objc_release(objc);
    - - 修饰符对应关系
        
        copy --> __strong (赋值使用新 copy 的对象)
        
        retain --> __strong
        
        strong --> __strong
        
        unsafe_unretained --> __unsafe_unretained
        
        weak --> __weak
        
        assign --> __unsafe_unretained
  - - - 使用散列表（引用计数表）来管理引用计数
        
        引用计数不依赖于内存块的状态，也就是说内存块出现突发状态，也能通过引用计数表来找到内存块所在位置
    - - 对象的头部有个引用计数
        
        简单
  - - - apple
        
        //创建自动释放池 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];// id obj = [NSObject new]; [obj autorelease]; //将 obj加到 AutoreleasePool //清理自动释放池 [pool drain];//相当于 releaseAll
      - GNUstep
        
        对象 autorelease 相当于 add 到 Autorelease 中
- - - - 建立在 GCD 的基础之上。
        解决痛点：
        
        任务之间依赖关系
        
        取消/暂停正在执行的任务
      - NSOpertation 子类
        NSInvocationOpertation
        NSBlockOperation
      - 特点：
        
        支持 Operation 之间建立依赖关系
        只有当一个operation 所以来的所有 operation 都执行完成，该operation 才开始执行
        
        支持一个可选的 completion block，
        
        支持 KVO 来观察 operation 执行状态的变化
        
        支持设置执行优先级
        
        支持取消操作
    - - Queue
        
        Queues
        
        global queues（全局并发队列）
        
        用户队列通过 dispatch_queue_create 创建的自定义队列
        
        如果某个线程堵塞了（永远不退出），那将不能获得该线程，其他线程不能跳转到该线程。（待确认）
        
        main_queue
        
        Serial Dispatch Queue
        
        使用一个线程
        
        Concurrent Dispatch Queue
        
        使用多个线程
        
        Create Queue
        dispatch_queue_t
        
        获取系统的
        
        dispatch_get_main_queue()
        
        Global Dispaatch Queue
        
        dispatch _queue_t globalDispatch = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0) DISPATCH_QUEUE_PRIORITY_LOW DISPATCH_QUEUE_PRIORITY_DEFAULT DISPATCH_QUEUE_PRIORITY_HIGH DISPATCH_QUEUE_PRIORITY_BACKGROUND
        
        dispatch_set_target_queue
        
        1 more item...
        
        // 串行队列 dispatch_queue_create("com.example.gcd.MySerialDispatchQueue", NULL) //并行队列 dispatch_queue_create("com.example.gcd.MyConcurrentDispatchQueue", DISPATCH_QUEUE_CONCURRENT)
        
        API
        
        dispatch_after
        
        dispatch_after(time,queue,^{})
        
        dispatch_time_t time = dispatch_time(DISPATCHTIME_NOW, 1ull * NSEC_PER_SEC)
        
        dispatch_group
        dispatch_group_t
        
        dispatch_group_async
        将 block 追加到并行队列
        
        dispatch_group_async(group, queue,^{})
        
        dispatch_group_wait
        
        dispatch_group_wait(group, DISPATCH_TIME_FOREVER)
        阻塞当前线程，只有当 group 执行完毕，才开始执行
        
        dispatch_group_notifify
        
        dispatch_group_notify(group,queue,^{})
        
        dispatch_barrier_async
        可以实现高效的数据库访问，和文件访问
        
        dispatch_async(queue, ^{ readA() }) dispatch_async(queue, ^{ writeA() }) dispatch_async(queue, ^{ readA()})
        有问题，无法保证读在写完成后执行
        dispatch_async(queue, ^{ readA() }) dispatch_barrier_async(queue, ^{}) dispatch_async(queue, ^{ readA() })
        保证了 dispatch_barrier 会阻塞队列的执行，直到 barrier 之前追加的 block 执行完成后才开始执行 barrier 之后追加的动作
        
        dspatch_apply
        重复将 block 添加到队列，会阻塞（sync）建议用一个 async 操作包一层
        
        dispatch_apply(10, queue, ^(size_t index) {})
        
        dispatch_suspend / dispatch_resume
        suspend 只对还没执行的 block 有用，开始执行的无效
        
        dispatch semaphore
        作用和锁很像，可以对资源进行管理，
        一次只能一个线程对某资源访问
        
        信号量来控制，为 0 时等待，>= 1 时不等待
        
        // 初始化为1 dispatch_semaphore_t semaphore = dispatch_semaphore_create(1) // 如果 >=1 ，将 Dispatch semaphore 减去 1。否则等待预设之间 dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER) // 将 Dispatch semaphore 加 1 dispatch_semaphore_signal
        疑惑 demo 中 block 直接对 semaphore 操作，但是没有使用 __block 修饰。
        
        好处：粒度更小。
        Serial dispatch 和 dispatch_barrier_async
        都是对整个 block 操作的。
        而 semaphore 可以对 block 内部细节做微控
        
        dispatch_once
        保证只执行一次指定处理
        
        static int initialized = NO; if (initialized) { // init initialized = YES }
        等同于
        static dispatch_once_t pred dispatch_once(&pred, ^{ // init })
        这样做的好处在多核 CPU，多线程环境，也可以保证只执行一次
        
        dispatch I/O
        读取大文件的时候，大大提高效率
        
        同步异步
        
        dispatch_async
        
        直接返回
        
        dispatch_sync
        
        等到队列的操作完成后才返回，阻塞之后的操作。
        不管是 Serial 还是 concurrent 都会阻塞
  - - - 锁
        
        lock 类型
        
        NSLock
        
        Mutex
        
        SpinLock
        
        Semaphore 信号量
        
        性能对比
        
        synchronized
    - - 使用锁（性能损耗）
      - get 和 set 方法放到串行队列
        可以有效避免属性的安全问题