OC 备忘录

俗话说，好记性不如烂笔头。学习过的东西最好都做个笔记，保留下来。将来忘记了，还能快速帮助我们记起来。而且在人生的不同阶段，看看自己留下的星星点点 真的是一件很美的事。

1. GCD (队列不代表线程)

1. 创建一个队列:
  (串行队列: DISPATCH_QUEUE_SERIAL，
   并行队列: DISPATCH_QUEUE_CONCURRENT)
   dispatch_queue_create("label", DISPATCH_QUEUE_CONCURRENT);

   串行队列，一次只能执行一个任务(一个block)。最多创建一个子线程。

2. 取得系统的队列:
   dispatch_get_main_queue() 主队列属于串行队列。

   dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
   全局队列，属于并行队列。有有优先级的区别。 后面那个0是预留参数，切只可传0 

3. dispatch_async(dispatch_queue_t queue, dispatch_block_t block);
   dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);
   同步 异步 调度队列。不一定开启新的线程。

   dispatch_barrier_sync(dispatch_queue_t queue, dispatch_block_t block);
   dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block);
   栅栏调度队列，起到隔离作用，异步的则根据栅栏很前后执行，同步的就必须先执行。
   即栅栏后的队列，一定比栅栏队列后执行。

4. 串行队列里面，同步调度相同的串行队列，会造成死锁。(互相等待)

5. 延迟执行任务 
   dispatch_after(dispatch_time_t when,   ->什么时间开始，到持续延迟多长时间
                  dispatch_queue_t queue, ->在哪个队列里面执行
                  dispatch_block_t block) ->任务

   dispatch_time(dispatch_time_t when, int64_t delta);
   DISPATCH_TIME_NOW 从现在开始，== 0
   DISPATCH_TIME_FOREVER  无穷大 
   NSEC_PER_SEC  1000000000纳秒 == 1秒 (这里的时间都是纳秒为单位)

6. 只执行一次的: (单例)
   static dispatch_once_t onceToken;
   dispatch_once(&onceToken, ^{
    // 只执行一次的任务
    ...
   });

7. 队列管理组
   dispatch_group_t group = dispatch_group_create();   //创建一个管理组

   dispatch_group_async(dispatch_group_t group, //队列加入组里
                        dispatch_queue_t queue,
                        dispatch_block_t block);

   等待group中多个异步任务执行完毕,在去处理任务:
   dispatch_group_wait(group, DISPATCH_TIME_FOREVER); //等待，会阻塞线程
   dispatch_group_notify(dispatch_group_t group,  //不会阻塞
                         dispatch_queue_t queue,
                         dispatch_block_t block);

   手动插入一个任务到队列组里:
   dispatch_group_enter(group);  --> 开始进入
   中间，处理我们独立的任务 (即加入这个管理组)
   dispatch_group_leave(group);  --> 有进就有出
   后面就可以调用 notify方法了

8. 并行指定次数任务 （for循环 是串行）
   dispatch_apply(size_t iterations,      //次数
                  dispatch_queue_t queue, //任务提交到的队列
                  void (^block)(size_t)); //参数是index

9. 挂起，和 恢复
   dispatch_suspend(concurrentQueue);  //挂起队列  （未执行的任务，会暂停）
   dispatch_resume(concurrentQueue);   //重新开始队列

10. 信号量
   dispatch_semaphore_create(long value);  //创建信号量 (0 等待，1可进)
   dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER); //信号量减1，或等待
   dispatch_semaphore_signal(semaphore);  //信号量加 1

11. 资源，source
   self.timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, concurrentQueue);
   dispatch_source_set_timer(self.timer,
                              DISPATCH_TIME_NOW,  //什么时候开始
                              1 * NSEC_PER_SEC,   //间隔
                              0 );  //偏差
   __block int i = 0;
   dispatch_source_set_event_handler(self.timer, ^{
       NSLog(@"开始执行 了%d", i++);
   });
   dispatch_resume(self.timer); //开始
   //dispatch_suspend(self.timer);  可暂停,否则无限执行

2. Block

只讨论ARC模式下的情况：
__block修饰的变量，允许在Blok中修改。但是该被retain的还是会被retain。
都是放在堆上的，所有在block里面引用 block的所属对象时，必须使用对象的弱引用。因为是弱引用，为了防止对象被提前释放掉，所以在block里面再次声明一个对象强引用该对象。 如下(两种方法):

__weak typeof(self) tempWeakSelf=self;//block 外面
@weakify(self)//block 外面

[self.demoView setCallBack:^(id obj) {
        
    @strongify(self) //block 里面
    typeof(self) strongSelf=tempWeakSelf; //block 里面
        
    strongSelf.view.backgroundColor = RandomColor;
    self.view.backgroundColor = RandomColor;
}];

3. Other Linker Flags

1. -ObjC 链接静态库中所有的OC代码(方法，category)到App
2. -all_load 链接静态库中所有的代码到App
3. -force_load 链接指定的静态库中所有的代码到App

4. Perform Single-Object Prelink 静态库中所有的对象文件合并成单一文件，只要这个单一文件有代码被使用，所有代码都会被链接到App
5. 伪符号 (无用的函数，变量) 在Category中加一些空的函数，无实际作用的全局变量(伪符号)。然后在引用Category的地方使用这些空函数、全局变量，那这个Category就会被链接到App中。

代码体积对比:
伪符号 < Perform Single-Object Prelink < -force_load < -ObjC < -all_load

4. 指令集

armv7 armv7s 对应32位iPhone处理器的指令集
arm64 对应64位iPhone处理器的指令集

i386 Mac32位处理器指令集
x86_64 Mac64位处理器指令集