iOS多线程实现3-GCD

时间 2019-11-10

标签 ios 多线程实现 gcd 栏目 iOS 繁體版

原文原文链接

原文连接：http://www.cnblogs.com/mddblog/p/4767559.html　　html

　　敲下gcd三个字母，搜狗第一条显示竟然是“滚床单” ^_^ios

1、介绍

　　GCD，英文全称是Grand Central Dispatch（功能强悍的中央调度器），基于C语言编写的一套多线程开发机制，所以使用时会以函数形式出现，且大部分函数以dispatch开头，虽然是C语言的但相对于苹果其它多线程实现方式，抽象层次更高，使用起来也更加方便。git

　　它是苹果为应对多核的并行运算提出的解决方案，它会自动利用多核进行并发处理和运算，且线程由系统自动管理（调度、运行），无需程序员参与，使用起来很是方便。程序员

2、任务和队列

　　GCD有两个核心：任务和队列。github

　　任务：要执行的操做或方法函数，队列：存听任务的集合，而咱们要作的就是将任务添加到队列而后执行，GCD会自动将队列中的任务按先进先出的方式取出并交给对应线程执行。注意任务的取出是按照先进先出的方式，这也是队列的特性，可是取出后的执行顺序则不必定，下面会详细讨论。缓存

　　1 任务网络

　　任务是一个比较抽象的概念，能够简单的认为是一个操做、一个函数、一个方法等等，在实际的开发中大可能是以block（block使用详见）的形式，使用起来也更加灵活。多线程

　　2 队列queue并发

有两种队列：串行队列和并行队列。串行队列：同步执行，在当前线程执行；并行队列：可由多个线程异步执行，但任务的取出仍是FIFO的。

　　　　队列建立，根据函数第二个参数来建立串行或并行队列。框架

// 参数1 队列名称
// 参数2 队列类型 DISPATCH_QUEUE_SERIAL/NULL串行队列，DISPATCH_QUEUE_CONCURRENT表明并行队列
// 下面代码为建立一个串行队列，也是实际开发中用的最多的
dispatch_queue_t serialQ = dispatch_queue_create("队列名", NULL);

另外系统提供了两种队列：全局队列和主队列。

　　　　全局队列属于并行队列，只不过已由系统建立的没有名字，且在全局可见（可用）。获取全局队列：

/* 取得全局队列
 第一个参数：线程优先级,设为默认便可，我的习惯写0，等同于默认
 第二个参数：标记参数，目前没有用，通常传入0
 */
serialQ = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

　　　　主队列属于串行队列，也由系统建立，只不过运行在主线程（UI线程）。获取主队列：

// 获取主队列
serialQ = dispatch_get_main_queue();

关于内存

　　　　queue属于一个对象，也是占用内存的，也会使用引用计数，当向queue添加一个任务时就会将这个queue retain一下，引用计数+1，直到全部任务都完成内存才会释放。（咱们在声明一个queue属性时要用strong)。

　　3 执行方式-2种

　　同步执行和异步执行。

　　　　同步执行：不会开启新的线程，在当前线程执行。

　　　　异步执行：gcd管理的线程池中有空闲线程就会从队列中取出任务执行，会开启线程。

　　下面为实现同步和异步的函数，函数功能为：将任务添加到队列并执行。

/* 同步执行
 第一个参数：执行任务的队列：串行、并行、全局、主队列
 第二个参数：block任务
 */
void dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);
// 异步执行
void dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

注意：默认状况下，新线程都没有开启runloop，因此当block任务完成后，线程都会自动被回收，假设咱们想在新开的线程中使用NSTimer，就必须开启runloop，可使用[[NSRunLoop currentRunLoop] run]开启当前线程，这是就要本身管理线程的回收等工做。

另外还有两个方法，实际开发中用的并非太多

dispatch_barrier_sync(dispatch_queue_t queue, dispatch_block_t block);

dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block);

　　加了一个barrier，意义在于：队列以前的block处理完成以后才开始处理队列中barrier的block，且barrier的block必须处理完以后，才能处理其它的block。

　　根据这个特性咱们能够实现123456一共6个block，可让特定几个并发执行完成以后，再并发执行剩下的block。好比123先并发，以后456再并发执行。具体代码以下(将barrier放在123与456之间便可)：

- (void)barrierTest {
    // 1 建立并发队列
    dispatch_queue_t BCqueue = dispatch_queue_create("BarrierConcurrent", DISPATCH_QUEUE_CONCURRENT);
    
    // 2.1 添加任务123
    dispatch_async(BCqueue, ^{
        NSLog(@"task1,%@", [NSThread currentThread]);
    });
    dispatch_async(BCqueue, ^{
        sleep(3);
        NSLog(@"task2,%@", [NSThread currentThread]);
    });
    dispatch_async(BCqueue, ^{
        sleep(1);
        NSLog(@"task3,%@", [NSThread currentThread]);
    });
    // 2.2 添加barrier
    dispatch_barrier_async(BCqueue, ^{
        NSLog(@"barrier");
    });
    // 2.3 添加任务456
    dispatch_async(BCqueue, ^{
        sleep(1);
        NSLog(@"task4,%@", [NSThread currentThread]);
    });
    dispatch_async(BCqueue, ^{
        NSLog(@"task5,%@", [NSThread currentThread]);
    });
    dispatch_async(BCqueue, ^{
        NSLog(@"task6,%@", [NSThread currentThread]);
    });
}

　　输出结果，为了显示效果，代码有延时操做：

22:33:56.822 GCDTest[32339:7753989] task1,<NSThread: 0x600000274780>{number = 3, name = (null)}
22:33:57.827 GCDTest[32339:7753986] task3,<NSThread: 0x600000271a00>{number = 5, name = (null)}
22:33:59.826 GCDTest[32339:7754004] task2,<NSThread: 0x600000275100>{number = 4, name = (null)}
22:33:59.826 GCDTest[32339:7754004] barrier
22:33:59.827 GCDTest[32339:7753986] task5,<NSThread: 0x600000271a00>{number = 5, name = (null)}
22:33:59.827 GCDTest[32339:7753987] task6,<NSThread: 0x608000279300>{number = 6, name = (null)}
22:34:00.828 GCDTest[32339:7754004] task4,<NSThread: 0x600000275100>{number = 4, name = (null)}

3、几种类型

　　很明显两种执行方式，两种队列。那么就有4种状况：串行队列同步执行、串行队列异步执行、并行队列同步执行、并行队列异步执行。哪种会开启新的线程？开几条？是否并发？记忆起来比较绕，可是只要抓住基本的就能够，为了方便理解，现分析以下：

　　1）串行队列，同步执行-----串行队列意味着顺序执行，同步执行意味着不开启线程（在当前线程执行）

　　2）串行队列,异步执行-----串行队列意味着任务顺序执行，异步执行说明要开线程, （若是开多个线程的话，不能保证串行队列顺序执行，因此只开一个线程）

　　3）并行队列,异步执行-----并行队列意味着执行顺序不肯定，异步执行意味着会开启线程，而并行队列又容许不按顺序执行，因此系统为了提升性能会开启多个线程，来队列取任务（队列中任务取出仍然是顺序取出的，只是线程执行无序）。

　　4）并行队列,同步执行-----同步执行意味着不开线程,则确定是顺序执行

　　5）死锁-----程序执行不出来(死锁) ；

4、死锁举例

主队列死锁：
这种死锁最多见，问题也最严重，会形成主线程卡住。缘由：主队列，若是主线程正在执行代码，就不调度任务；同步执行：一直执行第一个任务直到结束。二者互相等待形成死锁，示例以下：

- (void)mainThreadDeadLockTest {
    NSLog(@"begin");
    dispatch_sync(dispatch_get_main_queue(), ^{
        // 发生死锁下面的代码不会执行
        NSLog(@"middle");
    });
    // 发生死锁下面的代码不会执行，固然函数也不会返回，后果也最为严重
    NSLog(@"end");
}

在其它线程死锁，这种不会影响主线程：
缘由：serialQueue为串行队列，当代码执行到block1时正常，执行到dispatch_sync时，dispatch_sync等待block2执行完毕才会返回，而serialQueue是串行队列，它正在执行block1，只有等block1执行完毕后才会去执行block2，相互等待形成死锁

- (void)deadLockTest {
    // 其它线程的死锁
    dispatch_queue_t serialQueue = dispatch_queue_create("serial_queue", DISPATCH_QUEUE_SERIAL);
    dispatch_async(serialQueue, ^{
        // 串行队列block1
        NSLog(@"begin");
        dispatch_sync(serialQueue, ^{
            // 串行队列block2 发生死锁，下面的代码不会执行
            NSLog(@"middle");
        });
        // 不会打印
        NSLog(@"end");
    });
    // 函数会返回，不影响主线程
    NSLog(@"return");
}

5、经常使用举例

　　1 线程间通信

　　好比，为了提升用户体验，咱们通常在其余线程（非主线程）下载图片或其它网络资源，下载完成后咱们要更新UI，而UI更新必须在主线程执行，因此咱们常常会使用：

// 同步执行，会阻塞指导下面block中的代码执行完毕
dispatch_sync(dispatch_get_main_queue(), ^{
    // 主线程，UI更新
});
// 异步执行
dispatch_async(dispatch_get_main_queue(), ^{
    // 主线程，UI更新
});

　　2 信号量的使用

也属于线程间通信，下面的举例是常常用到的场景。在网络访问中，NSURLSession类都是异步的(找了好久没有找到同步的方法)，而有时咱们但愿可以像NSURLConnection同样能够同步访问，即在网络block调用完成以后作一些操做。那咱们可使用dispatch的信号量来解决：

/// 用于线程间通信，下面是等待一个网络完成
- (void)dispatchSemaphore {
    NSString *urlString = [@"https://www.baidu.com" stringByAddingPercentEncodingWithAllowedCharacters:[NSCharacterSet URLQueryAllowedCharacterSet]];
    // 设置缓存策略为每次都从网络加载 超时时间30秒
    NSURLRequest *request = [NSURLRequest requestWithURL:[NSURL URLWithString:urlString] cachePolicy:NSURLRequestReloadIgnoringLocalCacheData timeoutInterval:30];
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
    [[[NSURLSession sharedSession] dataTaskWithRequest:request completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
        // 处理完成以后，发送信号量
        NSLog(@"正在处理...");
        dispatch_semaphore_signal(semaphore);
    }] resume];
    // 等待网络处理完成
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    NSLog(@"处理完成！");
}

在上面的举例中dispatch_semaphore_signal的调用必须是在另外一个线程调用，由于当前线程已经dispatch_semaphore_wait阻塞。另外，dispatch_semaphore_wait最好不要在主线程调用

　　3 其它经常使用

　　全局队列，实现并发：

dispatch_async(dispatch_get_global_queue(0, 0), ^{
    // 要执行的代码
});

6、Dispatch Group调度组

　　使用调度组，能够轻松实如今一些任务完成后，作一些操做。好比具备顺序性要求的生产者消费者等等。

　　示例1 任务1完成以后执行任务2。

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {
    [self groupTest];
}
- (void)groupTest {
    // 建立一个组
    dispatch_group_t group = dispatch_group_create();
    NSLog(@"开始执行");
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
            // 任务1
            // 等待1s一段时间在执行
            [NSThread sleepForTimeInterval:1];
            NSLog(@"task1 running in %@",[NSThread currentThread]);
        });
        dispatch_group_notify(group, dispatch_get_global_queue(0, 0), ^{
            // 任务2
            NSLog(@"task2 running in %@",[NSThread currentThread]);
        });
    });
}

　　点击屏幕后，打印以下，能够看到任务1虽然等待了1s，任务2也不执行，只有任务1执行完毕才执行任务2.

2015-08-28 18:16:05.317 GCDTest[1468:229374] 开始执行
2015-08-28 18:16:06.323 GCDTest[1468:229457] task1 running in <NSThread: 0x7f8962f16900>{number = 2, name = (null)}
2015-08-28 18:16:06.323 GCDTest[1468:229456] task2 running in <NSThread: 0x7f8962c92750>{number = 3, name = (null)}

　　示例2，其实示例1并不经常使用，真正用到的是监控多个任务完成以后，回到主线程更新UI，或者作其它事情。

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {
    [self groupTest];
}
- (void)groupTest {
    // 建立一个组
    dispatch_group_t group = dispatch_group_create();
    NSLog(@"开始执行");
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
            // 关联任务1
            NSLog(@"task1 running in %@",[NSThread currentThread]);
        });
        dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
            // 关联任务2
            NSLog(@"task2 running in %@",[NSThread currentThread]);
        });
        dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
            // 关联任务3
            NSLog(@"task3 running in %@",[NSThread currentThread]);
        });
        dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
            // 关联任务4
            // 等待1秒
            [NSThread sleepForTimeInterval:1];
            NSLog(@"task4 running in %@",[NSThread currentThread]);
        });
        dispatch_group_notify(group, dispatch_get_main_queue(), ^{
            // 回到主线程执行
            NSLog(@"mainTask running in %@",[NSThread currentThread]);
        });
    });
}

　　点击屏幕后，打印以下，能够看到不管其它任务而后和执行，mainTask等待它们执行后才执行。

2015-08-28 18:24:14.312 GCDTest[1554:236273] 开始执行
2015-08-28 18:24:14.312 GCDTest[1554:236352] task3 running in <NSThread: 0x7fa8f1f0c9c0>{number = 4, name = (null)}
2015-08-28 18:24:14.312 GCDTest[1554:236354] task1 running in <NSThread: 0x7fa8f1d10750>{number = 2, name = (null)}
2015-08-28 18:24:14.312 GCDTest[1554:236351] task2 running in <NSThread: 0x7fa8f1c291a0>{number = 3, name = (null)}
2015-08-28 18:24:15.313 GCDTest[1554:236353] task4 running in <NSThread: 0x7fa8f1d0e7f0>{number = 5, name = (null)}
2015-08-28 18:24:15.313 GCDTest[1554:236273] mainTask running in <NSThread: 0x7fa8f1c13df0>{number = 1, name = main}

关于Dispatch对象内存管理问题

根据上面的代码，能够看出有关dispatch的对象并非OC对象，那么，用不用像对待Core Foundation框架的对象同样，使用retain/release来管理呢？答案是不用的！

若是是ARC环境，咱们无需管理，会像对待OC对象同样自动内存管理。
若是是MRC环境，不是使用retain/release，而是使用dispatch_retain/dispatch_release来管理。

测试用例github下载：https://github.com/mddios/GCDTest