iOS多线程 & GCD

进程

在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]);