iOS 多线程-基础篇

学习线程之前我们先温习下

进程：

屏幕快照 2018-12-01 下午2.52.13.png

线程：

屏幕快照 2018-12-01 下午2.54.40.png

多线程的原理：同一时间，cpu只能处理一条线程，只有一条线程在工作，多线程并发执行，其实是cpu快速的在多条线程间切换。
优点：1、提高程序的执行效率
2、提高cpu的利用率
缺点：线程多了就会消耗大量的cpu资源，降低程序性能，线程调度频率也会降低，同时耗电。

多线程.png

一、 NSTread介绍

是苹果官方提供的，使用起来比 pthread 更加面向对象，简单易用，可以直接操作线程对象。不过也需要需要程序员自己管理线程的生命周期。

//使用target对象的selector作为线程的任务执行体，该selector方法最多可以接收一个参数，该参数即为argument
- (instancetype)initWithTarget:(id)target selector:(SEL)selector object:(nullable id)argument

//使用block作为线程的任务执行体
- (instancetype)initWithBlock:(void (^)(void))block

/*
类方法，返回值为void
使用一个block作为线程的执行体，并直接启动线程
上面的实例方法返回NSThread对象需要手动调用start方法来启动线程执行任务
*/
+ (void)detachNewThreadWithBlock:(void (^)(void))block

/*
类方法，返回值为void
使用target对象的selector作为线程的任务执行体，该selector方法最多接收一个参数，该参数即为argument
同样的，该方法创建完县城后会自动启动线程不需要手动触发
*/
+ (void)detachNewThreadSelector:(SEL)selector toTarget:(id)target withObject:(nullable id)argument

NSTread子线程例子

NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(firstThread:) object:@"Hello, World"];
//设置线程的名字，方便查看
[thread setName:@"firstThread"];
//启动线程
[thread start];
}

//线程的任务执行体并接收一个参数arg
- (void)firstThread:(id)arg
{
NSLog(@"Task %@ %@", [NSThread currentThread], arg);
NSLog(@"Thread Task Complete");
}

常见API

// 获得主线程
+ (NSThread *)mainThread;    

// 判断是否为主线程(对象方法)
- (BOOL)isMainThread;

// 判断是否为主线程(类方法)
+ (BOOL)isMainThread;    

// 获得当前线程
NSThread *current = [NSThread currentThread];

// 线程的名字——setter方法
- (void)setName:(NSString *)n;    

// 线程的名字——getter方法
- (NSString *)name;

线程状态控制方法

// 线程进入就绪状态 -> 运行状态。当线程任务执行完毕，自动进入死亡状态
- (void)start;

// 线程进入阻塞状态
+ (void)sleepUntilDate:(NSDate *)date;
+ (void)sleepForTimeInterval:(NSTimeInterval)ti;

//强制停止线程  线程进入死亡状态
+ (void)exit;

线程间的通讯

// 在主线程上执行操作
- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait;
- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait modes:(NSArray<NSString *> *)array;
// equivalent to the first method with kCFRunLoopCommonModes

// 在指定线程上执行操作
- (void)performSelector:(SEL)aSelector onThread:(NSThread *)thr withObject:(id)arg waitUntilDone:(BOOL)wait modes:(NSArray *)array NS_AVAILABLE(10_5, 2_0);
- (void)performSelector:(SEL)aSelector onThread:(NSThread *)thr withObject:(id)arg waitUntilDone:(BOOL)wait NS_AVAILABLE(10_5, 2_0);

// 在当前线程上执行操作，调用 NSObject 的 performSelector:相关方法
- (id)performSelector:(SEL)aSelector;
- (id)performSelector:(SEL)aSelector withObject:(id)object;
- (id)performSelector:(SEL)aSelector withObject:(id)object1 withObject:(id)object2;

二、GCD Dispatch

GCD 可用于多核的并行运算
GCD 会自动利用更多的 CPU 内核（比如双核、四核）
GCD 会自动管理线程的生命周期（创建线程、调度任务、销毁线程）
程序员只需要告诉 GCD 想要执行什么任务，不需要编写任何线程管理代码

GCD任务和队列

GCD 中两个核心概念：任务和队列

任务

任务：就是执行操作的意思，换句话说就是你在线程中执行的那段代码。在 GCD 中是放在 block 中的

同步执行（sync）
- 同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等待，直到队列里面的任务完成之后再继续执行。
- 只能在当前线程中执行任务，不具备开启新线程的能力
异步执行（async）
- 异步添加任务到指定的队列中，它不会做任何等待，可以继续执行任务。
- 可以在新的线程中执行任务，具备开启新线程的能力。

// 同步执行任务创建方法
dispatch_sync(queue, ^{
// 这里放同步执行任务代码
});
// 异步执行任务创建方法
dispatch_async(queue, ^{
// 这里放异步执行任务代码
});

队列

队列（Dispatch Queue）：这里的队列指执行任务的等待队列，即用来存放任务的队列。队列是一种特殊的线性表，采用 FIFO（先进先出）的原则，即新任务总是被插入到队列的末尾，而读取任务的时候总是从队列的头部开始读取。每读取一个任务，则从队列中释放一个任务

串行队列（Serial Dispatch Queue）

每次只有一个任务被执行。让任务一个接着一个地执行。（只开启一个线程，一个任务执行完毕后，再执行下一个任务）

并发队列（Concurrent Dispatch Queue）

可以让多个任务并发（同时）执行。（可以开启多个线程，并且同时执行任务）
并发队列的并发功能只有在异步（dispatch_async）函数下才有效

队列的创建方法/获取方法

可以使用dispatch_queue_create来创建队列，需要传入两个参数，第一个参数表示队列的唯一标识符，用于 DEBUG，可为空，Dispatch Queue 的名称推荐使用应用程序 ID 这种逆序全程域名；第二个参数用来识别是串行队列还是并发队列。DISPATCH_QUEUE_SERIAL 表示串行队列，DISPATCH_QUEUE_CONCURRENT表示并发队列。

// 串行队列的创建方法
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);
// 并发队列的创建方法
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);

对于串行队列，GCD 提供了的一种特殊的串行队列：主队列（Main Dispatch Queue）

所有放在主队列中的任务，都会放到主线程中执行
可使用dispatch_get_main_queue()获得主队列。

// 主队列的获取方法
dispatch_queue_t queue = dispatch_get_main_queue();
对于并发队列，GCD 默认提供了全局并发队列（Global Dispatch Queue）

可以使用dispatch_get_global_queue来获取。需要传入两个参数。第一个参数表示队列优先级，一般用DISPATCH_QUEUE_PRIORITY_DEFAULT。第二个参数暂时没用，用0即可。

// 全局并发队列的获取方法
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

GCD 的基本使用

同步串行队列

dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
    dispatch_sync(queue, ^{
        // 追加任务1
        for (int i = 0; i < 2; ++i) {
            NSLog(@"1---%@",[NSThread currentThread]);
        }
    });
    
    dispatch_sync(queue, ^{
        // 追加任务2
        for (int i = 0; i < 2; ++i) {
            NSLog(@"2---%@",[NSThread currentThread]);
        }
    });

2018-12-03 15:58:42.790220+0800 001--Block[4215:271492] 1---<NSThread: 0x604000076a40>{number = 1, name = main}
2018-12-03 15:58:42.790508+0800 001--Block[4215:271492] 1---<NSThread: 0x604000076a40>{number = 1, name = main}
2018-12-03 15:58:42.790670+0800 001--Block[4215:271492] 2---<NSThread: 0x604000076a40>{number = 1, name = main}
2018-12-03 15:58:42.790809+0800 001--Block[4215:271492] 2---<NSThread: 0x604000076a40>{number = 1, name = main}

根据打印结果可知，同步串行队列即没有开启新的线程，也没有异步执行

同步并行队列

dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
    dispatch_sync(queue, ^{
        // 追加任务1
        for (int i = 0; i < 2; ++i) {
            NSLog(@"1---%@",[NSThread currentThread]);
        }
    });
    
    dispatch_sync(queue, ^{
        // 追加任务2
        for (int i = 0; i < 2; ++i) {
            NSLog(@"2---%@",[NSThread currentThread]);
        }
    });

2018-12-03 16:00:13.963915+0800 001--Block[4250:273199] 1---<NSThread: 0x600000076500>{number = 1, name = main}
2018-12-03 16:00:13.964146+0800 001--Block[4250:273199] 1---<NSThread: 0x600000076500>{number = 1, name = main}
2018-12-03 16:00:13.964329+0800 001--Block[4250:273199] 2---<NSThread: 0x600000076500>{number = 1, name = main}
2018-12-03 16:00:13.964605+0800 001--Block[4250:273199] 2---<NSThread: 0x600000076500>{number = 1, name = main}

根据两种打印我们发现：同步函数既不会开启新的线程，也不会执行并发任务

异步串行队列

NSLog(@"主线程：%@",[NSThread currentThread]);
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"1====%@",[NSThread currentThread]);      // 打印当前线程
        }
        
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"2====%@",[NSThread currentThread]);      // 打印当前线程
        }
    });

2018-12-03 16:06:46.425846+0800 001--Block[4371:279078] 主线程：<NSThread: 0x60000007a300>{number = 1, name = main}
2018-12-03 16:06:46.426329+0800 001--Block[4371:279184] 1====<NSThread: 0x604000464fc0>{number = 3, name = (null)}
2018-12-03 16:06:46.426596+0800 001--Block[4371:279184] 1====<NSThread: 0x604000464fc0>{number = 3, name = (null)}
2018-12-03 16:06:46.426860+0800 001--Block[4371:279184] 2====<NSThread: 0x604000464fc0>{number = 3, name = (null)}
2018-12-03 16:06:46.427033+0800 001--Block[4371:279184] 2====<NSThread: 0x604000464fc0>{number = 3, name = (null)}

结果：有开启新的线程，串行执行任务

异步并行队列

NSLog(@"主线程：%@",[NSThread currentThread]);
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"1====%@",[NSThread currentThread]);      // 打印当前线程
        }
        
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"2====%@",[NSThread currentThread]);      // 打印当前线程
        }
    });

2018-12-03 16:04:29.192038+0800 001--Block[4310:276444] 主线程：<NSThread: 0x6000000732c0>{number = 1, name = main}
2018-12-03 16:04:29.192416+0800 001--Block[4310:276688] 1====<NSThread: 0x60400027cf40>{number = 3, name = (null)}
2018-12-03 16:04:29.192436+0800 001--Block[4310:276690] 2====<NSThread: 0x60400027c340>{number = 4, name = (null)}
2018-12-03 16:04:29.192603+0800 001--Block[4310:276688] 1====<NSThread: 0x60400027cf40>{number = 3, name = (null)}
2018-12-03 16:04:29.192609+0800 001--Block[4310:276690] 2====<NSThread: 0x60400027c340>{number = 4, name = (null)}

结果：有开启新的线程，并发执行任务。想要出现明显的并发执行效果，可以sleep

死锁问题

【问题1】

NSLog(@"执行任务1");
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_sync(queue, ^{
NSLog(@"执行任务2");
});

NSLog(@"执行任务3");

输出：2018-12-03 16:21:09.388970+0800 001--Block[4468:285688] 执行任务1
(lldb)

死锁，dispatch_sync与main_queue造成死锁，任务3执行结束才会执行任务2；而主线程中是执行完sync才会执行任务3，造成互相等待死锁。

修改成异步，就不会死锁了，如下

NSLog(@"执行任务1");

dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_async(queue, ^{
NSLog(@"执行任务2");
});

NSLog(@"执行任务3");

【问题2】

NSLog(@"执行任务1");

dispatch_queue_t queue = dispatch_queue_create("myqueu", DISPATCH_QUEUE_SERIAL);
dispatch_async(queue, ^{ // 0
NSLog(@"执行任务2");

dispatch_sync(queue, ^{ // 1
NSLog(@"执行任务3");
});

NSLog(@"执行任务4");
});

NSLog(@"执行任务5");

输出：
2018-12-03 16:24:08.183248+0800 001--Block[4517:288411] 执行任务1
2018-12-03 16:24:08.183479+0800 001--Block[4517:288411] 执行任务5
2018-12-03 16:24:08.183497+0800 001--Block[4517:288659] 执行任务2
(lldb)

看打印是死锁了，执行任务3和执行任务4之间造成死锁。
原因：dispatch_async进来是串行，NSLog(@"执行任务2");、dispatch_sync、NSLog(@"执行任务4");需要顺序执行，dispatch_sync同步阻塞当前线程

修改

NSLog(@"执行任务1");
    dispatch_queue_t queue = dispatch_queue_create("myqueu", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{ // 0
        NSLog(@"执行任务2");
        
        dispatch_sync(queue, ^{ // 1
            NSLog(@"执行任务3");
        });
        
        NSLog(@"执行任务4");
    });
    
    NSLog(@"执行任务5");

看一些案例：

同步并发嵌套异步

- (void)syncConcurrentasync{
    
    NSLog(@"begin");
    dispatch_queue_t queue = dispatch_queue_create("com.gcd", DISPATCH_QUEUE_CONCURRENT);
    dispatch_sync(queue, ^{//block1
        NSLog(@"1");
        dispatch_async(queue, ^{//block2
            NSLog(@"2");
        });
        // sleep(1);
        NSLog(@"3");
        
    });
    NSLog(@"end");
}
2020-12-25 13:28:18.675262+0800 JeyRAC[77995:2073956] begin
2020-12-25 13:28:18.675379+0800 JeyRAC[77995:2073956] 1
2020-12-25 13:28:18.675479+0800 JeyRAC[77995:2073956] 3
2020-12-25 13:28:18.675493+0800 JeyRAC[77995:2074038] 2
2020-12-25 13:28:18.675551+0800 JeyRAC[77995:2073956] end

如果把sleep(1)放开

2020-12-25 13:29:08.428569+0800 JeyRAC[78025:2074874] begin
2020-12-25 13:29:08.428684+0800 JeyRAC[78025:2074874] 1
2020-12-25 13:29:08.428800+0800 JeyRAC[78025:2075061] 2
2020-12-25 13:29:09.429837+0800 JeyRAC[78025:2074874] 3
2020-12-25 13:29:09.430007+0800 JeyRAC[78025:2074874] end

总结：begin打印，此时是主线程中，同步任务block1，阻塞主线程，打印1，block2异步开启新线程，继续往下走，打印3，此时子线程block2走完，打印2.
加了sleep(1)，block2里面的子线程时间是不可控的，可能比3先打印

//同步并发嵌套同步

- (void)syncConcurrentsync{
    
    NSLog(@"begin");
    dispatch_queue_t queue = dispatch_queue_create("com.gcd", DISPATCH_QUEUE_CONCURRENT);
    dispatch_sync(queue, ^{//block1
        NSLog(@"1");
        dispatch_sync(queue, ^{//block2
            sleep(2);
            NSLog(@"2");
        });
        NSLog(@"3");
    });
    NSLog(@"end");
}
2020-12-25 13:36:51.089937+0800 JeyRAC[78207:2082457] begin
2020-12-25 13:36:51.090042+0800 JeyRAC[78207:2082457] 1
2020-12-25 13:36:53.091042+0800 JeyRAC[78207:2082457] 2
2020-12-25 13:36:53.091170+0800 JeyRAC[78207:2082457] 3
2020-12-25 13:36:53.091251+0800 JeyRAC[78207:2082457] end

同步任务会阻塞当前线程一步一步往下走就对了

同步串行嵌套异步步

- (void)syncSerialasync{
    NSLog(@"begin");
    dispatch_queue_t queue = dispatch_queue_create("com.gcd", DISPATCH_QUEUE_SERIAL);
    dispatch_sync(queue, ^{//block1
        NSLog(@"1");
        dispatch_async(queue, ^{//block2
            sleep(2);
            NSLog(@"2");
        });
        dispatch_async(queue, ^{//block3
            NSLog(@"4");
        });
        sleep(2);
        NSLog(@"3");
    });
//    sleep(5);
    NSLog(@"end");
}
2020-12-25 13:54:04.277575+0800 JeyRAC[78748:2101142] begin
2020-12-25 13:54:04.277679+0800 JeyRAC[78748:2101142] 1
2020-12-25 13:54:04.277778+0800 JeyRAC[78748:2101142] 3
2020-12-25 13:54:04.277834+0800 JeyRAC[78748:2101142] end
2020-12-25 13:54:06.280145+0800 JeyRAC[78748:2101348] 2
2020-12-25 13:54:06.280277+0800 JeyRAC[78748:2101348] 4

总结：进来dispatch_sync是同步，打印1。串行队列block1中包含NSLog(@"1");、block2、block3、NSLog(@"3");，串行队列block1是要执行完才会往下执行，所以打印3了才会继续执行子线程。
sleep(5)放开的话，2，4会在end前打印，异步跟这里就没什么关系了

主队列中异步：不会开辟新线程,不会阻塞当前线程
主队列中添加的任务需要等主线中的任务执行，再执行

- (void)main{
    NSLog(@"begin");
    dispatch_queue_t mainq = dispatch_get_main_queue();
    dispatch_async(mainq, ^{//block
        NSLog(@"1");
    });
    sleep(2);
    NSLog(@"end");
}
2020-12-25 14:46:37.602158+0800 JeyRAC[80011:2142108] begin
2020-12-25 14:46:39.603256+0800 JeyRAC[80011:2142108] end
2020-12-25 14:46:39.621192+0800 JeyRAC[80011:2142108] 1

拓展方法

dispatch_apply的循环

- (void)apply {
    dispatch_queue_t queue = dispatch_queue_create("dd", DISPATCH_QUEUE_CONCURRENT);
    for (int i = 0; i< 10; i++) {
        dispatch_async(queue, ^{
            NSLog(@"a-index==%d----线程%@", i, [NSThread currentThread]);
        });
    }
    dispatch_apply(10, queue, ^(size_t index) {
        NSLog(@"index==%ld", index);
    });
}
2020-12-25 15:25:20.606309+0800 JeyRAC[81046:2174844] index==0
2020-12-25 15:25:20.606322+0800 JeyRAC[81046:2175021] index==1
2020-12-25 15:25:20.606373+0800 JeyRAC[81046:2175020] a-index==0----线程<NSThread: 0x6000003f6900>{number = 6, name = (null)}
2020-12-25 15:25:20.606470+0800 JeyRAC[81046:2174844] index==2
2020-12-25 15:25:20.606480+0800 JeyRAC[81046:2175021] index==3
2020-12-25 15:25:20.606504+0800 JeyRAC[81046:2175051] a-index==2----线程<NSThread: 0x6000003a5800>{number = 8, name = (null)}
2020-12-25 15:25:20.606463+0800 JeyRAC[81046:2175019] a-index==1----线程<NSThread: 0x6000003fe240>{number = 7, name = (null)}
2020-12-25 15:25:20.606574+0800 JeyRAC[81046:2174844] index==4
2020-12-25 15:25:20.606580+0800 JeyRAC[81046:2175021] index==5
2020-12-25 15:25:20.606549+0800 JeyRAC[81046:2175052] a-index==3----线程<NSThread: 0x6000003a09c0>{number = 9, name = (null)}
2020-12-25 15:25:20.606573+0800 JeyRAC[81046:2175053] a-index==4----线程<NSThread: 0x6000003bcd80>{number = 10, name = (null)}
2020-12-25 15:25:20.606651+0800 JeyRAC[81046:2174844] index==6
2020-12-25 15:25:20.606620+0800 JeyRAC[81046:2175020] a-index==5----线程<NSThread: 0x6000003f6900>{number = 6, name = (null)}
2020-12-25 15:25:20.606747+0800 JeyRAC[81046:2175022] index==7
2020-12-25 15:25:20.606752+0800 JeyRAC[81046:2175025] index==8
2020-12-25 15:25:20.606774+0800 JeyRAC[81046:2175023] index==9
2020-12-25 15:25:20.606991+0800 JeyRAC[81046:2175021] a-index==6----线程<NSThread: 0x6000003bab40>{number = 5, name = (null)}
2020-12-25 15:25:20.607094+0800 JeyRAC[81046:2175054] a-index==7----线程<NSThread: 0x6000003a5c00>{number = 11, name = (null)}
2020-12-25 15:25:20.607109+0800 JeyRAC[81046:2175055] a-index==8----线程<NSThread: 0x6000003fc940>{number = 12, name = (null)}
2020-12-25 15:25:20.607153+0800 JeyRAC[81046:2175056] a-index==9----线程<NSThread: 0x6000003bea80>{number = 13, name = (null)}

两种for循环差不多，并行的异步中有的线程是相同的

GCD 栅栏方法：dispatch_barrier_async

在异步执行一些操作的时候，我们使用dispatch_barrier_async函数把异步操作暂时性的做成同步操作，就行一个栅栏一样分开

@property(nonatomic, strong) dispatch_queue_t queue;
@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    self.queue = dispatch_queue_create("rw_queue", DISPATCH_QUEUE_CONCURRENT);
    for (int i = 0; i < 10; i++) {
        [self read];
        [self read];
        [self read];
        [self write];
    }
}

- (void)read {
    dispatch_async(self.queue, ^{
        sleep(1);
        NSLog(@"read");
    });
}

- (void)write
{
    dispatch_barrier_async(self.queue, ^{
        sleep(1);
        NSLog(@"write");
    });
}

输出
2018-12-03 16:42:26.268215+0800 001--Block[4828:304463] read
2018-12-03 16:42:26.268216+0800 001--Block[4828:304464] read
2018-12-03 16:42:26.268216+0800 001--Block[4828:304462] read
2018-12-03 16:42:26.268521+0800 001--Block[4828:304462] write
2018-12-03 16:42:26.268734+0800 001--Block[4828:304462] read
2018-12-03 16:42:26.268738+0800 001--Block[4828:304464] read
2018-12-03 16:42:26.268756+0800 001--Block[4828:304463] read
2018-12-03 16:42:26.269386+0800 001--Block[4828:304463] write
2018-12-03 16:42:26.269962+0800 001--Block[4828:304463] read
2018-12-03 16:42:26.269967+0800 001--Block[4828:304464] read
2018-12-03 16:42:26.269979+0800 001--Block[4828:304462] read
2018-12-03 16:42:26.271003+0800 001--Block[4828:304462] write
2018-12-03 16:42:26.271579+0800 001--Block[4828:304462] read

GCD 延时执行方法：dispatch_after

- (void)after {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@"asyncMain---begin");
    
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        // 2.0秒后异步追加任务代码到主队列，并开始执行
        NSLog(@"after---%@",[NSThread currentThread]);  // 打印当前线程
    });
}

GCD 一次性代码（只执行一次）：dispatch_once

static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
// 只执行1次的代码(这里面默认是线程安全的)
});

GCD 队列组：dispatch_group

有时候我们会有这样的需求：分别异步执行2个耗时任务，然后当2个耗时任务都执行完毕后再回到主线程执行任务。这时候我们可以用到 GCD 的队列组

调用队列组的 dispatch_group_async 先把任务放到队列中，然后将队列放入队列组中。或者使用队列组的 dispatch_group_enter、dispatch_group_leave 组合来实现dispatch_group_async。
调用队列组的 dispatch_group_notify 回到指定线程执行任务。或者使用 dispatch_group_wait 回到当前线程继续向下执行（会阻塞当前线程）。
dispatch_group_enter 标志着一个任务追加到 group，执行一次，相当于 group 中未执行完毕任务数+1
dispatch_group_leave 标志着一个任务离开了 group，执行一次，相当于 group 中未执行完毕任务数-1
当 group 中未执行完毕任务数为0的时候，才会使dispatch_group_wait解除阻塞，以及执行追加到dispatch_group_notify中的任务。

- (void)groupNotify {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@"group---begin");
    
    dispatch_group_t group =  dispatch_group_create();
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任务1
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任务2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 等前面的异步任务1、任务2都执行完毕后，回到主线程执行下边任务
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
        }
        NSLog(@"group---end");
    });
}

输出：
2018-12-03 16:53:17.192618+0800 001--Block[4916:310729] currentThread---<NSThread: 0x604000078d80>{number = 1, name = main}
2018-12-03 16:53:17.192842+0800 001--Block[4916:310729] group---begin
2018-12-03 16:53:19.198080+0800 001--Block[4916:310976] 1---<NSThread: 0x600000274900>{number = 4, name = (null)}
2018-12-03 16:53:19.198079+0800 001--Block[4916:310975] 2---<NSThread: 0x604000462300>{number = 3, name = (null)}
2018-12-03 16:53:21.203811+0800 001--Block[4916:310975] 2---<NSThread: 0x604000462300>{number = 3, name = (null)}
2018-12-03 16:53:21.203844+0800 001--Block[4916:310976] 1---<NSThread: 0x600000274900>{number = 4, name = (null)}
2018-12-03 16:53:23.205322+0800 001--Block[4916:310729] 3---<NSThread: 0x604000078d80>{number = 1, name = main}
2018-12-03 16:53:25.206537+0800 001--Block[4916:310729] 3---<NSThread: 0x604000078d80>{number = 1, name = main}
2018-12-03 16:53:25.206825+0800 001--Block[4916:310729] group---end

- (void)group{
    
    dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t globalQ = dispatch_get_global_queue(0, 0);
    dispatch_group_enter(group);
    dispatch_group_async(group, globalQ, ^{
        dispatch_async(globalQ, ^{
            NSLog(@"1");
            dispatch_group_leave(group);
        });
    });
    dispatch_group_enter(group);

    dispatch_group_async(group, globalQ, ^{
        dispatch_async(globalQ, ^{
            NSLog(@"2");
            dispatch_group_leave(group);

        });
    });
    dispatch_group_enter(group);

    dispatch_group_async(group, globalQ, ^{
        dispatch_async(globalQ, ^{
            NSLog(@"3");
            dispatch_group_leave(group);

        });
        
    });
    dispatch_group_notify(group, globalQ, ^{
        NSLog(@"end");
    });
}

没有dispatch_group_enter(group);dispatch_group_leave(group);，dispatch_group_async里面是个异步，NSLog(@"end");可能打印了，但是dispatch_group_async里面的异步可能还没执行，加上dispatch_group_enter(group);dispatch_group_leave(group);可解决

NSOperation介绍

NSOperation、NSOperationQueue 是苹果提供给我们的一套多线程解决方案。实际上 NSOperation、NSOperationQueue 是基于 GCD 更高一层的封装，完全面向对象
NSOperationQueue 为我们提供了两种不同类型的队列：主队列和自定义队列。主队列运行在主线程之上，而自定义队列在后台执行

好处：
1、可添加完成的代码块，在操作完成后执行
2、添加操作之间的依赖关系，方便的控制执行顺序
3、设定操作执行的优先级
4、可以很方便的取消一个操作的执行
5、使用 KVO 观察对操作执行状态的更改：isExecuteing、isFinished、isCancelled
既然是基于 GCD 的更高一层的封装。那么，GCD 中的一些概念同样适用于 NSOperation、NSOperationQueue。在 NSOperation、NSOperationQueue 中也有类似的任务（操作）和队列（操作队列）的概念

NSOperation常用属性和方法

1、开始取消操作

(void)start：对于并发Operation需要重写该方法，也可以不把operation加入到队列中，手动触发执行，与调用普通方法一样
(void)main：非并发Operation需要重写该方法
(void)cancel：可取消操作，实质是标记 isCancelled 状态

2、判断操作状态方法

(BOOL)isFinished; 判断操作是否已经结束
(BOOL)isCancelled 判断操作是否已经标记为取消
(BOOL)isExecuting;判断操作是否正在在运行
(BOOL)isReady;判断操作是否处于准备就绪状态，这个值和操作的依赖关系相关。

3、操作同步

(void)waitUntilFinished;阻塞当前线程，直到该操作结束。可用于线程执行顺序的同步
(void)setCompletionBlock:(void (^)(void))block; 会在当前操作执行完毕时执行 completionBlock
(void)addDependency:(NSOperation *)op; 添加依赖，使当前操作依赖于操作 op 的完成
(void)removeDependency:(NSOperation *)op; 移除依赖，取消当前操作对操作 op 的依赖。
@property (readonly, copy) NSArray<NSOperation *> *dependencies; 在当前操作开始执行之前完成执行的所有操作对象数组。

NSOperationQueue 常用属性和方法

1、取消/暂停/恢复操作
- - (void)cancelAllOperations; 可以取消队列的所有操作
- - (BOOL)isSuspended; 判断队列是否处于暂停状态。 YES 为暂停状态，NO 为恢复状态
- - (void)setSuspended:(BOOL)b; 可设置操作的暂停和恢复，YES 代表暂停队列，NO 代表恢复队列
2、操作同步
- - (void)waitUntilAllOperationsAreFinished; 阻塞当前线程，直到队列中的操作全部执行完毕。
3、添加/获取操作
- - (void)addOperationWithBlock:(void (^)(void))block; 向队列中添加一个 NSBlockOperation 类型操作对象
- - (void)addOperations:(NSArray *)ops waitUntilFinished:(BOOL)wait;向队列中添加操作数组，wait 标志是否阻塞当前线程直到所有操作结束
- - (NSArray *)operations; 当前在队列中的操作数组（某个操作执行结束后会自动从这个数组清除）
- - (NSUInteger)operationCount; 当前队列中的操作数
4、获取队列
- + (id)currentQueue; 获取当前队列，如果当前线程不是在 NSOperationQueue 上运行则返回 nil。
- + (id)mainQueue; 获取主队列。

简单使用

NSOperation 需要配合 NSOperationQueue 来实现多线程。因为默认情况下，NSOperation 单独使用时系统同步执行操作，配合 NSOperationQueue 我们能更好的实现异步执行

实现步骤

1、创建操作：先将需要执行的操作封装到一个 NSOperation 对象中
2、创建队列：创建 NSOperationQueue 对象
3、将操作加入到队列中：将 NSOperation 对象添加到 NSOperationQueue 对象中
NSOperation 是个抽象类，不能用来封装操作。我们只有使用它的子类来封装操作

1、使用子类 NSInvocationOperation
2、使用子类 NSBlockOperation
3、自定义继承自 NSOperation 的子类，通过实现内部相应的方法来封装操作。

使用子类 NSInvocationOperation

- (void)Operation1{
    //1、创建NSInvocationOperation对象
    NSInvocationOperation *op = [[NSInvocationOperation alloc]initWithTarget:self selector:@selector(test) object:nil];
    //2、开始调用
    [op start];
}
- (void)test{
    for (NSInteger i = 0; i < 2; i++) {
        NSLog(@"当前线程:%@",[NSThread currentThread]);
    }
}

2018-12-03 17:09:59.378583+0800 001--Block[5018:320650] 当前线程:<NSThread: 0x60400006b540>{number = 1, name = main}
2018-12-03 17:09:59.378855+0800 001--Block[5018:320650] 当前线程:<NSThread: 0x60400006b540>{number = 1, name = main}

总结：在没有使用 NSOperationQueue、在主线程中单独使用使用子类 NSBlockOperation 执行一个操作的情况下，操作是在当前线程执行的，并没有开启新线程。

将操作加入到队列中

NSOperation 需要配合 NSOperationQueue 来实现多线程，总共有两种方法：

1、- (void)addOperation:(NSOperation *)op; 需要先创建操作，再将创建好的操作加入到创建好的队列中去
2、- (void)addOperationWithBlock:(void (^)(void))block; 无需先创建操作，在 block 中添加操作，直接将包含操作的 block 加入到队列中。

addOperation

- (void)Operation4{
    //1、创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];
    
    //2、创建操作
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"当前线程1:%@",[NSThread currentThread]);
    }];
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"当前线程2:%@",[NSThread currentThread]);
    }];
    NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"当前线程3:%@",[NSThread currentThread]);
    }];
    
    //3、添加操作
    [queue addOperation:op1];
    [queue addOperation:op2];
    [queue addOperation:op3];
}

2018-12-03 17:14:48.844950+0800 001--Block[5078:324522] 当前线程1:<NSThread: 0x600000470000>{number = 4, name = (null)}
2018-12-03 17:14:48.844951+0800 001--Block[5078:324525] 当前线程3:<NSThread: 0x604000275980>{number = 5, name = (null)}
2018-12-03 17:14:48.844950+0800 001--Block[5078:324523] 当前线程2:<NSThread: 0x60000007afc0>{number = 3, name = (null)}

addOperationWithBlock

无需先创建操作，在 block 中添加操作，直接将包含操作的 block 加入到队列中。

- (void)Operation5{
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];
    [queue addOperationWithBlock:^{
        NSLog(@"当前线程1:%@",[NSThread currentThread]);
    }];
    [queue addOperationWithBlock:^{
        NSLog(@"当前线程2:%@",[NSThread currentThread]);
    }];
    [queue addOperationWithBlock:^{
        NSLog(@"当前线程3:%@",[NSThread currentThread]);
    }];
}

这段代码和上面效果是一样的。

NSOperationQueue *queue = [[NSOperationQueue alloc]init];
    queue.maxConcurrentOperationCount = 1; // 串行队列
    queue.maxConcurrentOperationCount = 2; // 并发队列，一次只能执行两个并发队列
    [queue addOperationWithBlock:^{
        sleep(1);
        NSLog(@"当前线程1:%@",[NSThread currentThread]);
    }];
    [queue addOperationWithBlock:^{
        sleep(1);
        NSLog(@"当前线程2:%@",[NSThread currentThread]);
    }];
    [queue addOperationWithBlock:^{
        NSLog(@"当前线程3:%@",[NSThread currentThread]);
    }];

设置最大并发量，1，2执行完了才会到3

NSOperation 操作依赖

NSOperation、NSOperationQueue 最吸引人的地方是它能添加操作之间的依赖关系。通过操作依赖，我们可以很方便的控制操作之间的执行先后顺序

(void)addDependency:(NSOperation *)op; 添加依赖，使当前操作依赖于操作 op 的完成。
(void)removeDependency:(NSOperation *)op; 移除依赖，取消当前操作对操作 op 的依赖。
@property (readonly, copy) NSArray<NSOperation *> *dependencies; 在当前操作开始执行之前完成执行的所有操作对象数组

- (void)Operation6{
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];
    //2、创建操作
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        [NSThread sleepForTimeInterval:1];
        NSLog(@"当前线程1:%@",[NSThread currentThread]);
    }];
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        [NSThread sleepForTimeInterval:2];
        NSLog(@"当前线程2:%@",[NSThread currentThread]);
    }];
    NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"当前线程3:%@",[NSThread currentThread]);
    }];
    
    //3、添加依赖
    [op1 addDependency:op2];
    [op1 addDependency:op3];
    //4、添加操作
    [queue addOperation:op1];
    [queue addOperation:op2];
    [queue addOperation:op3];
}

2018-12-03 17:22:02.254933+0800 001--Block[5286:333230] 当前线程3:<NSThread: 0x604000460600>{number = 3, name = (null)}
2018-12-03 17:22:04.259007+0800 001--Block[5286:333238] 当前线程2:<NSThread: 0x604000462440>{number = 4, name = (null)}
2018-12-03 17:22:05.264331+0800 001--Block[5286:333230] 当前线程1:<NSThread: 0x604000460600>{number = 3, name = (null)}

最后编辑于：2020.12.25 15:57:31

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 205,033评论 6赞 478
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 87,725评论 2赞 381
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 151,473评论 0赞 338
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 54,846评论 1赞 277
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 63,848评论 5赞 368
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 48,691评论 1赞 282
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 38,053评论 3赞 399
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,700评论 0赞 258
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 42,856评论 1赞 300
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,676评论 2赞 323
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 37,787评论 1赞 333
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,430评论 4赞 321
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 39,034评论 3赞 307
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 29,990评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,218评论 1赞 260
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 45,174评论 2赞 352
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,526评论 2赞 343