进程
在ios中，一个进程代表一个app
进程之间相互独立
一个进程挂了不会影响其他进程
线程
一个进程必须至少有一个线程，程序启动的时候，默认开启一条线程，也就是主线程
线程之间可以资源共享
一个线程挂了，进程也就挂了，其他线程也跟着挂了
app处理的任何事务都是在线程中
多线程
对于单核CPU来说，同一时间，只执行一条线程，多线程的效果是由于CPU在不停的快速切换线程
多线程的生命周期
线程的优先级越高，是不是意味着任务的执行越快？
线程执行的快慢，除了要看优先级，还需要查看资源的大小（即任务的复杂度）、以及 CPU 调度情况
多线程的安全隐患
资源共享，当多个线程访问同一块资源时，很容易引发数据错乱、空指针等问题
互斥锁（即同步锁）：@synchronized、NSLock
确保同一时间，只有一条线程能够执行，当有新线程访问时，新线程就会进入休眠，等待CPU下一次调配
**synchronized **
使用注意：如果加锁的对象是nil,是锁不住的，很容易造成野指针，我们一般使用@synchronized (self)，当然如果可以保证对象不为nil，也可以不用锁self
NSLock
NSLock *lock = [[NSLock alloc] init];
[lock lock];
[lock unlock];
性能上会比synchronized好一点，但是用起来要注意解锁，如果代码逻辑不健壮，导致无法解锁，会堵塞线程
自旋锁
确保同一时间，只有一条线程能够执行，当有新线程访问时，新线程就会处于忙等待状态，避免了重新调配，但是它会一直尝试执行代码，比较消耗性能,一般会在复杂度较低的情况下才去使用
atomic 原子锁
OC中属性的默认修饰，本质是在set方法中，加了一把自旋锁，能够保证同一时间，只有一条线程对属性进行写的操作，但是读是不保证的，又消耗性能，所以在APP开发中基本不使用，mac开发中常用
nonatomic 非原子锁
没有任何锁，性能高，APP开发中常用
GCD
将任务添加到队列，并指定任务执行的函数
优势
自动利用更多的CPU内核（比如双核、四核）
自动管理线程的生命周期（创建线程、调度任务、销毁线程）
程序员只需要告诉GCD想要执行什么任务，不需要编写任何线程管理代码
GCD基本使用
dispatch_async(<#dispatch_queue_t _Nonnull queue#>, <#^(void)block#>)
将任务（block），添加到队列（dispatch_queue_t）中执行
dispatch_async( dispatch_queue_create("队列", NULL), ^{
NSLog(@"GCD基本使用");
});
执行方式
同步执行 dispatch_sync
不创建新的线程，马上立刻执行任务，并且堵塞当前线程
异步执行 dispatch_async
创建新的线程，不马上执行任务，不堵塞当前线程
队列
队列是一种特殊的线性表，遵循先进先出（FIFO）原则，即新任务总是被插入到队尾，而任务的读取从队首开始读取。每读取一个任务，则动队列中释放一个任务
**串行队列 **
每次只有一个任务被执行，等待上一个任务执行完毕再执行下一个，即只开启一个线程
// 串行队列的获取方法
dispatch_queue_t serialQueue1 = dispatch_queue_create("com.CJL.Queue", NULL);
dispatch_queue_t serialQueue2 = dispatch_queue_create("com.CJL.Queue", DISPATCH_QUEUE_SERIAL);
并行队列
一次可以并发执行多个任务，即开启多个线程，并同时执行任务
// 并发队列的获取方法
dispatch_queue_t concurrentQueue = dispatch_queue_create("com.CJL.Queue", DISPATCH_QUEUE_CONCURRENT);
dispatch_get_main_queue（主队列）
GCD中提供的特殊的串行队列，通常在返回主线程 更新UI时使用
如果当前主线程正在有任务执行，那么无论主队列中当前被添加了什么任务，都不会被调度
由于是串行队列，也不会开启新的线程
dispatch_get_global_queue(0, 0) 全局并发队列（Global Dispatch Queue）
GCD提供的默认的并发队列
第一个参数表示队列优先级，默认优先级为DISPATCH_QUEUE_PRIORITY_DEFAULT=0，在ios9之后，已经被服务质量（quality-of-service）取代
//全局并发队列的获取方法
dispatch_queue_t globalQueue = dispatch_get_global_queue(0, 0);
//优先级从高到低（对应的服务质量）依次为
- DISPATCH_QUEUE_PRIORITY_HIGH -- QOS_CLASS_USER_INITIATED
- DISPATCH_QUEUE_PRIORITY_DEFAULT -- QOS_CLASS_DEFAULT
- DISPATCH_QUEUE_PRIORITY_LOW -- QOS_CLASS_UTILITY
- DISPATCH_QUEUE_PRIORITY_BACKGROUND -- QOS_CLASS_BACKGROUND
//主队列 + 全局并发队列的日常使用
dispatch_async(dispatch_get_global_queue(0, 0), ^{
//执行耗时操作
dispatch_async(dispatch_get_main_queue(), ^{
//回到主线程进行UI操作
});
});
主队列 + 同步函数
dispatch_sync(dispatch_get_main_queue(), ^{
NSLog(@"1");
});
我们发现直接崩溃了
主队列是一个串行队列，只能按顺序一个任务一个任务的完成，现在追加一个任务到串行队列的末尾，还要求同步（立刻）执行。造成了当前任务和新添加的任务打架的情况，导致崩溃
主队列 + 异步函数主队列本身就是一个一个的干活，无论是不是异步，都要一个一个来，所以不开辟线程，顺序执行
全局并发队列 + 同步函数
同步函数本身就不开辟线程，并且要求立刻执行，所以还是一个一个来
全局并发队列 + 异步函数
开辟新线程，无序执行任务
dispatch_after 延迟执行
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"2s后");
});
dispatch_once 仅执行一次
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
//创建单例、method swizzled或其他任务
NSLog(@"创建单例");
});
dispatch_group_t
将多个任务分成组，接收组的消息状态，比如请求多个接口，当所有接口都完成后，再进行逻辑处理等
dispatch_group_t group = dispatch_group_create();
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
dispatch_group_async(group, queue, ^{
NSLog(@"1");
});
dispatch_group_async(group, queue, ^{
// sleep(2);
NSLog(@"2");
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
NSLog(@"done");
});
long timeout = dispatch_group_wait(group, dispatch_time(DISPATCH_TIME_NOW, 1 *NSEC_PER_SEC));
NSLog(@"timeout = %ld", timeout);
if (timeout == 0) {
NSLog(@"按时完成任务");
}else{
NSLog(@"超时");
}
dispatch_barrier_async
栅栏函数，将队列中的任务隔开，先执行栅栏前的任务，再执行栅栏任务，再执行栅栏后的任务
dispatch_queue_t queue = dispatch_queue_create("CJL", DISPATCH_QUEUE_CONCURRENT);
NSLog(@"开始 - %@", [NSThread currentThread]);
dispatch_async(queue, ^{
sleep(5);
NSLog(@"延迟5s的任务1 - %@", [NSThread currentThread]);
});
NSLog(@"第一次结束 - %@", [NSThread currentThread]);
//由于并发队列异步执行任务是乱序执行完毕的，所以使用栅栏函数可以很好的控制队列内任务执行的顺序
dispatch_barrier_async(queue, ^{
NSLog(@"------------栅栏任务------------%@", [NSThread currentThread]);
});
NSLog(@"栅栏结束 - %@", [NSThread currentThread]);
dispatch_async(queue, ^{
sleep(2);
NSLog(@"延迟2s的任务2 - %@", [NSThread currentThread]);
});
NSLog(@"第二次结束 - %@", [NSThread currentThread]);
