iOS-开辟子线程(NSThread、NSOperationQueue、GCD)_ios 开启子线程

本节主要总结一些开辟子线程的常用的几种方法。

一、通过NSThread类开辟子线程

1.NSThread手动开启子线程

// 创建线程对象.
NSThread *thread = [[NSThread alloc]initWithTarget:self selector:@selector(eat) object:nil];
thread.name = @"a";

// 手动开启线程
[thread start];
1
2
3
4
5
6

// 手动取消线程
[thread cancel]
1
2

2.NSThread自动开启子线程

    // 创建线程对象自动开启，无返回值
    [NSThread detachNewThreadSelector:@selector(eat) toTarget:self withObject:nil];
1
2
3

除了创建启动外，NSThread 还以很多方法，更多方法可以去NSThread.h类的定义里去看，写的很详细。

3.子线程中执行完之后，回到主线程：

[self performSelectorOnMainThread:@selector(mainQueue) withObject:nil waitUntilDone:NO];
1

二、通过NSOperationQueue类开辟子线程

1.Queue (队列)中是 NSOperation 对象

一个 NSOperation 对象就是一个任务(一段功能代码)，本身和线程没有关系(不能开子线程)。
NSOperation 只是一个抽象类，所以不能封装任务。但它有 2 个子类用于封装任务。分别是：NSInvocationOperation 和 NSBlockOperation 。创建一个 Operation 后，需要调用 start 方法来启动任务，它会默认在当前队列同步执行。当然你也可以在中途取消一个任务，只需要调用其 cancel 方法即可。这种方式任务都是在主线程中执行。

    // NSInvocationOperation 创建任务对象(多个)
    NSInvocationOperation *invocation1 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(eat) object:nil];
    NSInvocationOperation *invocation2 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(eat) object:nil];


    // NSBlockOperation 创建任务对象
    __weak typeof(self) weakSelf = self;
    //__weak ViewController *weakSelf = self;
    NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
        [weakSelf eat]; // 任务1
    }];
    // addExecutionBlock会创建一个新的线程来执行任务，而不是在同一个子线程中。   
    [blockOperation addExecutionBlock:^{
        [weakSelf eat]; // 任务2
    }];
    [blockOperation addExecutionBlock:^{
        [weakSelf eat]; // 任务3
    }];

    // 开启线程
    [invocation1 start];
    [invocation2 start];
    [blockOperation1 start];
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

也可以直接添加进队列 NSOperationQueue 里面，任务会自动执行，不需要你再手动调用start方法。NSOperation 和 NSOperationQueue 类似于 GCD 的 任务 和 队列。这种方式任务都是在子线程中执行。

    // 创建 operationQueue 队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    //NSOperationQueue 有一个属性 maxConcurrentOperationCount 最大并发数，用来设置最多可以让多少个任务同时执行。当你把它设置为 1 的时候，变为串行队列！

    queue.maxConcurrentOperationCount = 1;

    [queue addOperation:invocation1];
    [queue addOperation:invocation2];

    [queue addOperation:blockOperation];
1
2
3
4
5
6
7
8
9
10
11

NSOperation 取消任务调用

    [invocation1 cancel];
    [blockOperation cancel];
1
2

2.子线程中执行完之后，回到主线程：

   [[NSOperationQueue mainQueue] addOperationWithBlock:^{
        [weakSelf mainQueue];
    }];
1
2
3

NSOperation 还有好多属性方法，具体的可以NSOperation.h里面查看，会找到你需要的方法属性。

3.任务执行完成后回调

 [blockOperation setCompletionBlock:^{
     // 任务都执行完后回调
 }];
1
2
3

三、通过GCD开辟子线程

在 GCD 中，加入了两个非常重要的概念： 任务 和 队列。
任务：即操作，你想要干什么，说白了就是一段代码，在 GCD 中就是一个 Block，所以添加任务十分方便。任务有两种执行方式： 同步执行 和 异步执行，他们之间的区别在于 是否会创建新的线程。

1.GCD 核心: 队列和任务
2.队列: 串行队列和并行队列.
3.任务: block块 和 函数
4.程序本身有一个串行队列(主线程).
5.有4个并行队列(优先级区别).
6.自定义一个串行队列
7.自定义并行队列.

同步和异步区别：同步（sync） 和 异步（async） 的主要区别在于会不会阻塞当前线程，直到 Block 中的任务执行完毕！ 如果是同步（sync） 操作，它会阻塞当前线程并等待 Block 中的任务执行完毕，然后当前线程才会继续往下运行。 如果是异步（async）操作，当前线程会直接往下执行，它不会阻塞当前线程。

队列：用于存放任务。一共有两种队列， 串行队列 和 并行队列。

串行队列: 放到串行队列的任务，GCD 会 FIFO（先进先出） 地取出来一个，执行一个，然后取下一个，这样一个一个的执行。

并行队列: 放到并行队列的任务，GCD 也会 FIFO的取出来，但不同的是，它取出来一个就会放到别的线程，然后再取出来一个又放到另一个的线程。这样由于取的动作很快，忽略不计，看起来，所有的任务都是一起执行的。不过需要注意，GCD 会根据系统资源控制并行的数量，所以如果任务很多，它并不会让所有任务同时执行。

任何需要刷新 UI 的工作都要在主队列执行，所以一般耗时的任务都要放到别的线程执行。

它自己可以创建 串行队列, 也可以创建 并行队列.它有两个参数，第一个参数是标识符，用于 DEBUG 的时候标识唯一的队列，可以为空。第二个才是最重要的。第二个参数用来表示创建的队列是串行的还是并行的，传入DISPATCH_QUEUE_SERIAL 或 NULL 表示创建串行队列。传入 DISPATCH_QUEUE_CONCURRENT 表示创建并行队列。

//***************** 自定义串行队列 *****************//
// 串行队列 SERIAL
dispatch_queue_t queue = dispatch_queue_create("SERIAL", DISPATCH_QUEUE_SERIAL);

    // 防止循环引用 使用 __weak 修饰
    __weak typeof(self)weakSelf = self;
    // 异步任务 分线程中执行 不会阻塞主线程
    dispatch_async(queue, ^{
        [weakSelf eat];
    });
   // 同步任务 主线程中执行 会阻塞当前线程
    dispatch_sync(queue, ^{        
        [weakSelf eat];
    });
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

    //***************** 自定义并行队列 *****************//
    // 并行队列 CONCURRENT
    dispatch_queue_t queue2 = dispatch_queue_create("CONCURRENT", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue2, ^{
        [weakSelf eat];
    });
    dispatch_sync(queue2, ^{
        [weakSelf eat];
    });
1
2
3
4
5
6
7
8
9

//***************** 获取系统的4个并行队列 ****************//
    dispatch_queue_t queue4 = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_async(queue4, ^{
        [weakSelf eat];
    });
1
2
3
4
5

解决异步情况下抢占资源问题，可以加锁NSLock。获取资源时lock住，获取完资源后unlock。或者用@synchronized包裹获取资源代码。

1.子线程中执行完之后，回到主线程：

dispatch_async(dispatch_get_main_queue(), ^{
     // 更新UI
});
1
2
3

2.所有任务执行完成后回调

   dispatch_group_t group = dispatch_group_create();
   dispatch_group_async(group，queue2，^{执行任务A});
   dispatch_group_async(group，queue2，^{执行任务B});
   dispatch_group_async(group，queue2，^{执行任务C});
   dispatch_group_notify(group, dispatch_get_main_queue(), ^{
       NSLog(@"queue2的所有任务都执行完了");
   });
1
2
3
4
5
6
7

借鉴博客：
http://www.jianshu.com/p/0b0d9b1f1f19
http://www.ruanyifeng.com/blog/2013/04/processes_and_threads.html
http://guimingsu.com/blog/2015/12/22/thread/

总结

1.无论使用哪种方法进行多线程开发，每个线程启动后并不一定立即执行相应的操作，具体什么时候由系统调度，CPU空闲时就会执行。

2.NSBlockOperation 添加任务 addExecutionBlock 任务全部完成时回调方法 setCompletionBlock；GCD任务全部完成时回调方法 dispatch_group_notify。

3.NSThread适合轻量级多线程开发，要手动控制线程，线程总数无法控制，无法线程依赖。

4.对于简单的多线程开发建议使用NSObject的扩展方法完成，而不必使用NSThread。

5.可以使用NSThread的currentThread方法取得当前线程，使用 sleepForTimeInterval:方法让当前线程休眠。

6.NSOperation进行多线程开发可以控制线程总数及线程依赖关系。

7.创建一个NSOperation不应该直接调用start方法, 如果直接start则会在主线程中调用, 而是应该放到NSOperationQueue中启动。

8.相比NSInvocationOperation推荐使用NSBlockOperation，代码简单，同时由于闭包性使它没有传参问题。

9.NSOperation是对GCD面向对象的封装，但是GCD基于C语言开发，效率却更高. 建议如果任务之间有依赖关系或者想要监听任务完成状态的情况下优先选择NSOperation否则使用GCD。

10.在GCD中串行队列中的任务被安排到一个单一的子线程中，可以方便地控制执行顺序；并发队列在多个线程中执行（前提是使用异步方法），顺序控制相对复杂，但是更高效。

11.在GDC中一个操作是多线程执行还是单线程执行取决于当前队列类型和执行方法，只有队列类型为并发队列并且使用异步方法执行时才能在多个线程中并发执行。

12.相比使用NSLock，@synchronized更加简单。

13.主队列是个串行队列，但是它不会新建子线程，所以当在主队列中执行dispatch_sync 时会卡死。

Demo下载地址https://github.com/MichaelSSY/ThreadTest