iOS多线程全套：线程生命周期，多线程的四种解决方案，线程安全问题，GCD的使用，NSOperation的使用

时间  2019-11-16
标签 ios 多线程 全套 线程 生命周期 四种 解决 方案 安全问题 gcd 使用 nsoperation 栏目 iOS 繁體版
原文   原文链接

目的

本文主要是分享iOS多线程的相关内容，为了更系统的讲解，将分为如下7个方面来展开描述。git

  1. 多线程的基本概念
  2. 线程的状态与生命周期
  3. 多线程的四种解决方案：pthread，NSThread，GCD，NSOperation
  4. 线程安全问题
  5. NSThread的使用
  6. GCD的理解与使用
  7. NSOperation的理解与使用

Demo 在这里：WHMultiThreadDemo Demo的运行gif图以下：程序员

example5.gif

1、多线程的基本概念

进程：能够理解成一个运行中的应用程序，是系统进行资源分配和调度的基本单位，是操做系统结构的基础，主要管理资源。github

线程：是进程的基本执行单元，一个进程对应多个线程。安全

主线程：处理UI，全部更新UI的操做都必须在主线程上执行。不要把耗时操做放在主线程，会卡界面。多线程

多线程：在同一时刻，一个CPU只能处理1条线程，但CPU能够在多条线程之间快速的切换，只要切换的足够快，就形成了多线程一同执行的假象。并发

线程就像火车的一节车箱，进程则是火车。车箱（线程）离开火车（进程）是没法跑动的，而火车（进程）至少有一节车箱（主线程）。多线程能够看作多个车箱，它的出现是为了提升效率。 多线程是经过提升资源使用率来提升系统整体的效率。app

咱们运用多线程的目的是：将耗时的操做放在后台执行！异步

多线程

2、线程的状态与生命周期

线程的生命周期是：新建 - 就绪 - 运行 - 阻塞 - 死亡async

下面分别阐述线程生命周期中的每一步函数

新建：实例化线程对象

就绪：向线程对象发送start消息，线程对象被加入可调度线程池等待CPU调度。

运行：CPU 负责调度可调度线程池中线程的执行。线程执行完成以前，状态可能会在就绪和运行之间来回切换。就绪和运行之间的状态变化由CPU负责，程序员不能干预。

阻塞：当知足某个预约条件时，可使用休眠或锁，阻塞线程执行。sleepForTimeInterval（休眠指定时长），sleepUntilDate（休眠到指定日期），@synchronized(self)：（互斥锁）。

死亡：正常死亡，线程执行完毕。非正常死亡，当知足某个条件后，在线程内部停止执行/在主线程停止线程对象

还有线程的exit和cancel [NSThread exit]：一旦强行终止线程，后续的全部代码都不会被执行。 [thread cancel]取消：并不会直接取消线程，只是给线程对象添加 isCancelled 标记。

3、多线程的四种解决方案

多线程的四种解决方案分别是：pthread，NSThread，GCD， NSOperation。

pthread：运用C语言，是一套通用的API，可跨平台Unix/Linux/Windows。线程的生命周期由程序员管理。 NSThread：面向对象，可直接操做线程对象。线程的生命周期由程序员管理。 GCD：代替NSThread，能够充分利用设备的多核，自动管理线程生命周期。 NSOperation：底层是GCD，比GCD多了一些方法，更加面向对象，自动管理线程生命周期。

4、线程安全问题

当多个线程访问同一块资源时，很容易引起数据错乱和数据安全问题。就比如几我的在同一时修改同一个表格，形成数据的错乱。

解决多线程安全问题的方法

方法一：互斥锁（同步锁）

@synchronized(锁对象) {
    // 须要锁定的代码
}
复制代码

判断的时候锁对象要存在，若是代码中只有一个地方须要加锁，大多都使用self做为锁对象，这样能够避免单独再建立一个锁对象。 加了互斥作的代码，当新线程访问时，若是发现其余线程正在执行锁定的代码，新线程就会进入休眠。

方法二：自旋锁 加了自旋锁，当新线程访问代码时，若是发现有其余线程正在锁定代码，新线程会用死循环的方式，一直等待锁定的代码执行完成。至关于不停尝试执行代码，比较消耗性能。 属性修饰atomic自己就有一把自旋锁。

下面说一下属性修饰nonatomic 和 atomic

nonatomic 非原子属性,同一时间能够有不少线程读和写
atomic 原子属性(线程安全)，保证同一时间只有一个线程可以写入(可是同一个时间多个线程均可以取值)，atomic 自己就有一把锁(自旋锁)

atomic：线程安全，须要消耗大量的资源
nonatomic：非线程安全，不过效率更高，通常使用nonatomic
复制代码

5、NSThread的使用

No.1：NSThread建立线程

NSThread有三种建立方式：

  • init方式
  • detachNewThreadSelector建立好以后自动启动
  • performSelectorInBackground建立好以后也是直接启动
/** 方法一，须要start */
NSThread *thread1 = [[NSThread alloc] initWithTarget:self selector:@selector(doSomething1:) object:@"NSThread1"];
// 线程加入线程池等待CPU调度，时间很快，几乎是马上执行
[thread1 start];
    
/** 方法二，建立好以后自动启动 */
[NSThread detachNewThreadSelector:@selector(doSomething2:) toTarget:self withObject:@"NSThread2"];
    
/** 方法三，隐式建立，直接启动 */
[self performSelectorInBackground:@selector(doSomething3:) withObject:@"NSThread3"];

- (void)doSomething1:(NSObject *)object {
    // 传递过来的参数
    NSLog(@"%@",object);
    NSLog(@"doSomething1：%@",[NSThread currentThread]);
}

- (void)doSomething2:(NSObject *)object {
    NSLog(@"%@",object);
    NSLog(@"doSomething2：%@",[NSThread currentThread]);
}

- (void)doSomething3:(NSObject *)object {
    NSLog(@"%@",object);
    NSLog(@"doSomething3：%@",[NSThread currentThread]);
}
复制代码

No.2：NSThread的类方法

  • 返回当前线程
// 当前线程
[NSThread currentThread];
NSLog(@"%@",[NSThread currentThread]);

// 若是number=1，则表示在主线程，不然是子线程
打印结果：<NSThread: 0x608000261380>{number = 1, name = main}
复制代码
  • 阻塞休眠
//休眠多久
[NSThread sleepForTimeInterval:2];
//休眠到指定时间
[NSThread sleepUntilDate:[NSDate date]];
复制代码
  • 类方法补充
//退出线程
[NSThread exit];
//判断当前线程是否为主线程
[NSThread isMainThread];
//判断当前线程是不是多线程
[NSThread isMultiThreaded];
//主线程的对象
NSThread *mainThread = [NSThread mainThread];
复制代码

No.3：NSThread的一些属性

//线程是否在执行
thread.isExecuting;
//线程是否被取消
thread.isCancelled;
//线程是否完成
thread.isFinished;
//是不是主线程
thread.isMainThread;
//线程的优先级，取值范围0.0到1.0，默认优先级0.5，1.0表示最高优先级，优先级高，CPU调度的频率高
 thread.threadPriority;
复制代码

Demo：WHMultiThreadDemo

6、GCD的理解与使用

No.1：GCD的特色

  • GCD会自动利用更多的CPU内核
  • GCD自动管理线程的生命周期（建立线程，调度任务，销毁线程等）
  • 程序员只须要告诉 GCD 想要如何执行什么任务，不须要编写任何线程管理代码

No.2：GCD的基本概念

任务（block）：任务就是将要在线程中执行的代码，将这段代码用block封装好，而后将这个任务添加到指定的执行方式（同步执行和异步执行），等待CPU从队列中取出任务放到对应的线程中执行。

同步（sync）：一个接着一个，前一个没有执行完，后面不能执行，不开线程。

异步（async）：开启多个新线程，任务同一时间能够一块儿执行。异步是多线程的代名词

队列：装载线程任务的队形结构。(系统以先进先出的方式调度队列中的任务执行)。在GCD中有两种队列：串行队列和并发队列。

并发队列：线程能够同时一块儿进行执行。其实是CPU在多条线程之间快速的切换。（并发功能只有在异步（dispatch_async）函数下才有效）

串行队列：线程只能依次有序的执行。

GCD总结：将任务(要在线程中执行的操做block)添加到队列(本身建立或使用全局并发队列)，而且指定执行任务的方式(异步dispatch_async，同步dispatch_sync)

No.3：队列的建立方法

  • 使用dispatch_queue_create来建立队列对象，传入两个参数，第一个参数表示队列的惟一标识符，可为空。第二个参数用来表示串行队列（DISPATCH_QUEUE_SERIAL）或并发队列（DISPATCH_QUEUE_CONCURRENT）。
// 串行队列
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
// 并发队列
dispatch_queue_t queue1 = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
复制代码

GCD的队列还有另外两种：

  • 主队列：主队列负责在主线程上调度任务，若是在主线程上已经有任务正在执行，主队列会等到主线程空闲后再调度任务。一般是返回主线程更新UI的时候使用。dispatch_get_main_queue()
dispatch_async(dispatch_get_global_queue(0, 0), ^{
        // 耗时操做放在这里
        
        dispatch_async(dispatch_get_main_queue(), ^{
            // 回到主线程进行UI操做
            
        });
    });
复制代码
  • 全局并发队列：全局并发队列是就是一个并发队列，是为了让咱们更方便的使用多线程。dispatch_get_global_queue(0, 0)
//全局并发队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//全局并发队列的优先级
#define DISPATCH_QUEUE_PRIORITY_HIGH 2 // 高优先级
#define DISPATCH_QUEUE_PRIORITY_DEFAULT 0 // 默认（中）优先级
#define DISPATCH_QUEUE_PRIORITY_LOW (-2) // 低优先级
#define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN // 后台优先级
//iOS8开始使用服务质量，如今获取全局并发队列时，能够直接传0
dispatch_get_global_queue(0, 0);
复制代码

No.4：同步/异步/任务、建立方式

同步（sync）使用dispatch_sync来表示。 异步（async）使用dispatch_async。 任务就是将要在线程中执行的代码，将这段代码用block封装好。 代码以下：

// 同步执行任务
    dispatch_sync(dispatch_get_global_queue(0, 0), ^{
        // 任务放在这个block里
        NSLog(@"我是同步执行的任务");

    });
    // 异步执行任务
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        // 任务放在这个block里
        NSLog(@"我是异步执行的任务");

    });
复制代码

Demo：WHMultiThreadDemo

No.5：GCD的使用

因为有多种队列（串行/并发/主队列）和两种执行方式（同步/异步），因此他们之间能够有多种组合方式。

串行同步 串行异步 并发同步 并发异步 主队列同步 主队列异步

  • 串行同步 执行完一个任务，再执行下一个任务。不开启新线程。
/** 串行同步 */
- (void)syncSerial {
    
    NSLog(@"\n\n**************串行同步***************\n\n");
    
    // 串行队列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
    
    // 同步执行
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行同步1 %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行同步2 %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行同步3 %@",[NSThread currentThread]);
        }
    });
}
复制代码

输入结果为顺序执行，都在主线程：

串行同步1   <NSThread: 0x60000007c500>{number = 1, name = main}
串行同步1   <NSThread: 0x60000007c500>{number = 1, name = main}
串行同步1   <NSThread: 0x60000007c500>{number = 1, name = main}
串行同步2   <NSThread: 0x60000007c500>{number = 1, name = main}
串行同步2   <NSThread: 0x60000007c500>{number = 1, name = main}
串行同步2   <NSThread: 0x60000007c500>{number = 1, name = main}
串行同步3   <NSThread: 0x60000007c500>{number = 1, name = main}
串行同步3   <NSThread: 0x60000007c500>{number = 1, name = main}
串行同步3   <NSThread: 0x60000007c500>{number = 1, name = main}
复制代码
  • 串行异步 开启新线程，但由于任务是串行的，因此仍是按顺序执行任务。
/** 串行异步 */
- (void)asyncSerial {
    
    NSLog(@"\n\n**************串行异步***************\n\n");
    
    // 串行队列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
    
    // 同步执行
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行异步1 %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行异步2 %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行异步3 %@",[NSThread currentThread]);
        }
    });
}
复制代码

输入结果为顺序执行，有不一样线程：

串行异步1   <NSThread: 0x60000026d740>{number = 3, name = (null)}
串行异步1   <NSThread: 0x60000026d740>{number = 3, name = (null)}
串行异步1   <NSThread: 0x60000026d740>{number = 3, name = (null)}
串行异步2   <NSThread: 0x60000026d740>{number = 3, name = (null)}
串行异步2   <NSThread: 0x60000026d740>{number = 3, name = (null)}
串行异步2   <NSThread: 0x60000026d740>{number = 3, name = (null)}
串行异步3   <NSThread: 0x60000026d740>{number = 3, name = (null)}
串行异步3   <NSThread: 0x60000026d740>{number = 3, name = (null)}
串行异步3   <NSThread: 0x60000026d740>{number = 3, name = (null)}
复制代码
  • 并发同步 由于是同步的，因此执行完一个任务，再执行下一个任务。不会开启新线程。
/** 并发同步 */
- (void)syncConcurrent {
    
    NSLog(@"\n\n**************并发同步***************\n\n");
    
    // 并发队列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
    
    // 同步执行
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"并发同步1 %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"并发同步2 %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"并发同步3 %@",[NSThread currentThread]);
        }
    });
}
复制代码

输入结果为顺序执行，都在主线程：

并发同步1   <NSThread: 0x60000007c500>{number = 1, name = main}
并发同步1   <NSThread: 0x60000007c500>{number = 1, name = main}
并发同步1   <NSThread: 0x60000007c500>{number = 1, name = main}
并发同步2   <NSThread: 0x60000007c500>{number = 1, name = main}
并发同步2   <NSThread: 0x60000007c500>{number = 1, name = main}
并发同步2   <NSThread: 0x60000007c500>{number = 1, name = main}
并发同步3   <NSThread: 0x60000007c500>{number = 1, name = main}
并发同步3   <NSThread: 0x60000007c500>{number = 1, name = main}
并发同步3   <NSThread: 0x60000007c500>{number = 1, name = main}
复制代码
  • 并发异步 任务交替执行，开启多线程。
/** 并发异步 */
- (void)asyncConcurrent {
    
    NSLog(@"\n\n**************并发异步***************\n\n");
    
    // 并发队列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
    
    // 同步执行
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"并发异步1 %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"并发异步2 %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"并发异步3 %@",[NSThread currentThread]);
        }
    });
}
复制代码

输入结果为无序执行，有多条线程：

并发异步1   <NSThread: 0x60000026d740>{number = 3, name = (null)}
并发异步2   <NSThread: 0x60000026dc80>{number = 4, name = (null)}
并发异步3   <NSThread: 0x60800026ab40>{number = 5, name = (null)}
并发异步1   <NSThread: 0x60000026d740>{number = 3, name = (null)}
并发异步2   <NSThread: 0x60000026dc80>{number = 4, name = (null)}
并发异步3   <NSThread: 0x60800026ab40>{number = 5, name = (null)}
并发异步1   <NSThread: 0x60000026d740>{number = 3, name = (null)}
并发异步2   <NSThread: 0x60000026dc80>{number = 4, name = (null)}
并发异步3   <NSThread: 0x60800026ab40>{number = 5, name = (null)}
复制代码
  • 主队列同步 若是在主线程中运用这种方式，则会发生死锁，程序崩溃。
/** 主队列同步 */
- (void)syncMain {
    
    NSLog(@"\n\n**************主队列同步，放到主线程会死锁***************\n\n");
    
    // 主队列
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"主队列同步1 %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"主队列同步2 %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"主队列同步3 %@",[NSThread currentThread]);
        }
    });
}
复制代码

主队列同步形成死锁的缘由： 若是在主线程中运用主队列同步，也就是把任务放到了主线程的队列中。 而同步对于任务是马上执行的，那么当把第一个任务放进主队列时，它就会立马执行。 但是主线程如今正在处理syncMain方法，任务须要等syncMain执行完才能执行。 syncMain执行到第一个任务的时候，又要等第一个任务执行完才能往下执行第二个和第三个任务。 这样syncMain方法和第一个任务就开始了互相等待，造成了死锁。

  • 主队列异步 在主线程中任务按顺序执行。
/** 主队列异步 */
- (void)asyncMain {
    
    NSLog(@"\n\n**************主队列异步***************\n\n");
    
    // 主队列
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"主队列异步1 %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"主队列异步2 %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"主队列异步3 %@",[NSThread currentThread]);
        }
    });
}
复制代码

输入结果为在主线程中按顺序执行：

主队列异步1   <NSThread: 0x60000007c500>{number = 1, name = main}
主队列异步1   <NSThread: 0x60000007c500>{number = 1, name = main}
主队列异步1   <NSThread: 0x60000007c500>{number = 1, name = main}
主队列异步2   <NSThread: 0x60000007c500>{number = 1, name = main}
主队列异步2   <NSThread: 0x60000007c500>{number = 1, name = main}
主队列异步2   <NSThread: 0x60000007c500>{number = 1, name = main}
主队列异步3   <NSThread: 0x60000007c500>{number = 1, name = main}
主队列异步3   <NSThread: 0x60000007c500>{number = 1, name = main}
主队列异步3   <NSThread: 0x60000007c500>{number = 1, name = main}
复制代码
  • GCD线程之间的通信 开发中须要在主线程上进行UI的相关操做，一般会把一些耗时的操做放在其余线程，好比说图片文件下载等耗时操做。 当完成了耗时操做以后，须要回到主线程进行UI的处理，这里就用到了线程之间的通信。
- (IBAction)communicationBetweenThread:(id)sender {
    
    // 异步
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        // 耗时操做放在这里，例以下载图片。（运用线程休眠两秒来模拟耗时操做）
        [NSThread sleepForTimeInterval:2];
        NSString *picURLStr = @"http://www.bangmangxuan.net/uploads/allimg/160320/74-160320130500.jpg";
        NSURL *picURL = [NSURL URLWithString:picURLStr];
        NSData *picData = [NSData dataWithContentsOfURL:picURL];
        UIImage *image = [UIImage imageWithData:picData];
        
        // 回到主线程处理UI
        dispatch_async(dispatch_get_main_queue(), ^{
            // 在主线程上添加图片
            self.imageView.image = image;
        });
    });
}
复制代码

上面的代码是在新开的线程中进行图片的下载，下载完成以后回到主线程显示图片。

  • GCD栅栏 当任务须要异步进行，可是这些任务须要分红两组来执行，第一组完成以后才能进行第二组的操做。这时候就用了到GCD的栅栏方法dispatch_barrier_async。
- (IBAction)barrierGCD:(id)sender {
    
    // 并发队列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
    
    // 异步执行
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"栅栏：并发异步1 %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"栅栏：并发异步2 %@",[NSThread currentThread]);
        }
    });
    
    dispatch_barrier_async(queue, ^{
        NSLog(@"------------barrier------------%@", [NSThread currentThread]);
        NSLog(@"******* 并发异步执行，可是34必定在12后面 *********");
    });
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"栅栏：并发异步3 %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"栅栏：并发异步4 %@",[NSThread currentThread]);
        }
    });
}
复制代码

上面代码的打印结果以下，开启了多条线程，全部任务都是并发异步进行。可是第一组完成以后，才会进行第二组的操做。

栅栏：并发异步1   <NSThread: 0x60000026d740>{number = 3, name = (null)}
栅栏：并发异步2   <NSThread: 0x60000026e480>{number = 6, name = (null)}
栅栏：并发异步1   <NSThread: 0x60000026d740>{number = 3, name = (null)}
栅栏：并发异步2   <NSThread: 0x60000026e480>{number = 6, name = (null)}
栅栏：并发异步1   <NSThread: 0x60000026d740>{number = 3, name = (null)}
栅栏：并发异步2   <NSThread: 0x60000026e480>{number = 6, name = (null)}
 ------------barrier------------<NSThread: 0x60000026e480>{number = 6, name = (null)}
******* 并发异步执行，可是34必定在12后面 *********
栅栏：并发异步4   <NSThread: 0x60000026d740>{number = 3, name = (null)}
栅栏：并发异步3   <NSThread: 0x60000026e480>{number = 6, name = (null)}
栅栏：并发异步4   <NSThread: 0x60000026d740>{number = 3, name = (null)}
栅栏：并发异步3   <NSThread: 0x60000026e480>{number = 6, name = (null)}
栅栏：并发异步4   <NSThread: 0x60000026d740>{number = 3, name = (null)}
栅栏：并发异步3   <NSThread: 0x60000026e480>{number = 6, name = (null)}
复制代码
  • GCD延时执行 当须要等待一会再执行一段代码时，就能够用到这个方法了：dispatch_after。
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    // 5秒后异步执行
    NSLog(@"我已经等待了5秒！");
});
复制代码
  • GCD实现代码只执行一次 使用dispatch_once能保证某段代码在程序运行过程当中只被执行1次。能够用来设计单例。
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
    NSLog(@"程序运行过程当中我只执行了一次！");
});
复制代码
  • GCD快速迭代 GCD有一个快速迭代的方法dispatch_apply，dispatch_apply能够同时遍历多个数字。
- (IBAction)applyGCD:(id)sender {
    
    NSLog(@"\n\n************** GCD快速迭代 ***************\n\n");
    
    // 并发队列
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    
    // dispatch_apply几乎同时遍历多个数字
    dispatch_apply(7, queue, ^(size_t index) {
        NSLog(@"dispatch_apply：%zd======%@",index, [NSThread currentThread]);
    });
}
复制代码

打印结果以下：

dispatch_apply：0======<NSThread: 0x60000007c500>{number = 1, name = main}
dispatch_apply：1======<NSThread: 0x60000007c500>{number = 1, name = main}
dispatch_apply：2======<NSThread: 0x60000007c500>{number = 1, name = main}
dispatch_apply：3======<NSThread: 0x60000007c500>{number = 1, name = main}
dispatch_apply：4======<NSThread: 0x60000007c500>{number = 1, name = main}
dispatch_apply：5======<NSThread: 0x60000007c500>{number = 1, name = main}
dispatch_apply：6======<NSThread: 0x60000007c500>{number = 1, name = main}
复制代码
  • GCD队列组 异步执行几个耗时操做，当这几个操做都完成以后再回到主线程进行操做，就能够用到队列组了。 队列组有下面几个特色：

全部的任务会并发的执行(不按序)。 全部的异步函数都添加到队列中，而后再归入队列组的监听范围。 使用dispatch_group_notify函数，来监听上面的任务是否完成，若是完成, 就会调用这个方法。

队列组示例代码：

- (void)testGroup {
    dispatch_group_t group =  dispatch_group_create();
    
    dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
        NSLog(@"队列组：有一个耗时操做完成！");
    });
    
    dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
        NSLog(@"队列组：有一个耗时操做完成！");
    });
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        NSLog(@"队列组：前面的耗时操做都完成了，回到主线程进行相关操做");
    });
}
复制代码

打印结果以下：

队列组：有一个耗时操做完成！
队列组：有一个耗时操做完成！
队列组：前面的耗时操做都完成了，回到主线程进行相关操做
复制代码

至此，GCD的相关内容叙述完毕。下面让咱们继续学习NSOperation。

Demo：WHMultiThreadDemo

7、NSOperation的理解与使用

No.1：NSOperation简介

NSOperation是基于GCD之上的更高一层封装，NSOperation须要配合NSOperationQueue来实现多线程。

NSOperation实现多线程的步骤以下：

1. 建立任务：先将须要执行的操做封装到NSOperation对象中。
2. 建立队列：建立NSOperationQueue。
3. 将任务加入到队列中：将NSOperation对象添加到NSOperationQueue中。
复制代码

须要注意的是，NSOperation是个抽象类，实际运用时中须要使用它的子类，有三种方式：

  1. 使用子类NSInvocationOperation
  2. 使用子类NSBlockOperation
  3. 定义继承自NSOperation的子类，经过实现内部相应的方法来封装任务。

No.2：NSOperation的三种建立方式

  • NSInvocationOperation的使用 建立NSInvocationOperation对象并关联方法，以后start。
- (void)testNSInvocationOperation {
    // 建立NSInvocationOperation
    NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOperation) object:nil];
    // 开始执行操做
    [invocationOperation start];
}

- (void)invocationOperation {
    NSLog(@"NSInvocationOperation包含的任务，没有加入队列========%@", [NSThread currentThread]);
}
复制代码

打印结果以下，获得结论：程序在主线程执行，没有开启新线程。 这是由于NSOperation多线程的使用须要配合队列NSOperationQueue，后面会讲到NSOperationQueue的使用。

NSInvocationOperation包含的任务，没有加入队列========<NSThread: 0x6000000783c0>{number = 1, name = main}
复制代码
  • NSBlockOperation的使用 把任务放到NSBlockOperation的block中，而后start。
- (void)testNSBlockOperation {
    // 把任务放到block中
    NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"NSBlockOperation包含的任务，没有加入队列========%@", [NSThread currentThread]);
    }];
    
    [blockOperation start];
}
复制代码

执行结果以下，能够看出：主线程执行，没有开启新线程。 一样的，NSBlockOperation能够配合队列NSOperationQueue来实现多线程。

NSBlockOperation包含的任务，没有加入队列========<NSThread: 0x6000000783c0>{number = 1, name = main}
复制代码

可是NSBlockOperation有一个方法addExecutionBlock:，经过这个方法可让NSBlockOperation实现多线程。

- (void)testNSBlockOperationExecution {
    NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"NSBlockOperation运用addExecutionBlock主任务========%@", [NSThread currentThread]);
    }];
    
    [blockOperation addExecutionBlock:^{
        NSLog(@"NSBlockOperation运用addExecutionBlock方法添加任务1========%@", [NSThread currentThread]);
    }];
    [blockOperation addExecutionBlock:^{
        NSLog(@"NSBlockOperation运用addExecutionBlock方法添加任务2========%@", [NSThread currentThread]);
    }];
    [blockOperation addExecutionBlock:^{
        NSLog(@"NSBlockOperation运用addExecutionBlock方法添加任务3========%@", [NSThread currentThread]);
    }];
    
    [blockOperation start];
}
复制代码

执行结果以下，能够看出，NSBlockOperation建立时block中的任务是在主线程执行，而运用addExecutionBlock加入的任务是在子线程执行的。

NSBlockOperation运用addExecutionBlock========<NSThread: 0x60800006ccc0>{number = 1, name = main}
addExecutionBlock方法添加任务1========<NSThread: 0x60800007ec00>{number = 3, name = (null)}
addExecutionBlock方法添加任务3========<NSThread: 0x6000002636c0>{number = 5, name = (null)}
addExecutionBlock方法添加任务2========<NSThread: 0x60800007e800>{number = 4, name = (null)}
复制代码
  • 运用继承自NSOperation的子类 首先咱们定义一个继承自NSOperation的类，而后重写它的main方法，以后就可使用这个子类来进行相关的操做了。
/*******************"WHOperation.h"*************************/

#import <Foundation/Foundation.h>

@interface WHOperation : NSOperation

@end


/*******************"WHOperation.m"*************************/

#import "WHOperation.h"

@implementation WHOperation

- (void)main {
    for (int i = 0; i < 3; i++) {
        NSLog(@"NSOperation的子类WHOperation======%@",[NSThread currentThread]);
    }
}

@end


/*****************回到主控制器使用WHOperation**********************/

- (void)testWHOperation {
    WHOperation *operation = [[WHOperation alloc] init];
    [operation start];
}
复制代码

运行结果以下，依然是在主线程执行。

SOperation的子类WHOperation======<NSThread: 0x608000066780>{number = 1, name = main}
NSOperation的子类WHOperation======<NSThread: 0x608000066780>{number = 1, name = main}
NSOperation的子类WHOperation======<NSThread: 0x608000066780>{number = 1, name = main}
复制代码

因此，NSOperation是须要配合队列NSOperationQueue来实现多线程的。下面就来讲一下队列NSOperationQueue。

No.3：队列NSOperationQueue

NSOperationQueue只有两种队列：主队列、其余队列。其余队列包含了串行和并发。

主队列的建立以下，主队列上的任务是在主线程执行的。

NSOperationQueue *mainQueue = [NSOperationQueue mainQueue];
复制代码

其余队列（非主队列）的建立以下，加入到‘非队列’中的任务默认就是并发，开启多线程。

NSOperationQueue *queue = [[NSOperationQueue alloc] init];
复制代码

注意：

  1. 非主队列（其余队列）能够实现串行或并行。
  2. 队列NSOperationQueue有一个参数叫作最大并发数：maxConcurrentOperationCount。
  3. maxConcurrentOperationCount默认为-1，直接并发执行，因此加入到‘非队列’中的任务默认就是并发，开启多线程。
  4. 当maxConcurrentOperationCount为1时，则表示不开线程，也就是串行。
  5. 当maxConcurrentOperationCount大于1时，进行并发执行。
  6. 系统对最大并发数有一个限制，因此即便程序员把maxConcurrentOperationCount设置的很大，系统也会自动调整。因此把最大并发数设置的很大是没有意义的。

No.4：NSOperation + NSOperationQueue

把任务加入队列，这才是NSOperation的常规使用方式。

  • addOperation添加任务到队列

先建立好任务，而后运用- (void)addOperation:(NSOperation *)op 方法来吧任务添加到队列中，示例代码以下：

- (void)testOperationQueue {
    // 建立队列，默认并发
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    
    // 建立操做，NSInvocationOperation
    NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOperationAddOperation) object:nil];
    // 建立操做，NSBlockOperation
    NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"addOperation把任务添加到队列======%@", [NSThread currentThread]);
        }
    }];
    
    [queue addOperation:invocationOperation];
    [queue addOperation:blockOperation];
}


- (void)invocationOperationAddOperation {
    NSLog(@"invocationOperation===aaddOperation把任务添加到队列====%@", [NSThread currentThread]);
}
复制代码

运行结果以下，能够看出，任务都是在子线程执行的，开启了新线程！

invocationOperation===addOperation把任务添加到队列====<NSThread: 0x60800026ed00>{number = 4, name = (null)}
addOperation把任务添加到队列======<NSThread: 0x60800026e640>{number = 3, name = (null)}
addOperation把任务添加到队列======<NSThread: 0x60800026e640>{number = 3, name = (null)}
addOperation把任务添加到队列======<NSThread: 0x60800026e640>{number = 3, name = (null)}
复制代码
  • addOperationWithBlock添加任务到队列

这是一个更方便的把任务添加到队列的方法，直接把任务写在block中，添加到任务中。

- (void)testAddOperationWithBlock {
    // 建立队列，默认并发
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    
    // 添加操做到队列
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"addOperationWithBlock把任务添加到队列======%@", [NSThread currentThread]);
        }
    }];
}
复制代码

运行结果以下，任务确实是在子线程中执行。

addOperationWithBlock把任务添加到队列======<NSThread: 0x6000000752c0>{number = 3, name = (null)}
addOperationWithBlock把任务添加到队列======<NSThread: 0x6000000752c0>{number = 3, name = (null)}
addOperationWithBlock把任务添加到队列======<NSThread: 0x6000000752c0>{number = 3, name = (null)}
复制代码
  • 运用最大并发数实现串行 上面已经说过，能够运用队列的属性maxConcurrentOperationCount（最大并发数）来实现串行，值须要把它设置为1就能够了，下面咱们经过代码验证一下。
- (void)testMaxConcurrentOperationCount {
    // 建立队列，默认并发
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    
    // 最大并发数为1，串行
    queue.maxConcurrentOperationCount = 1;
    
    // 最大并发数为2，并发
// queue.maxConcurrentOperationCount = 2;
    
    
    // 添加操做到队列
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"addOperationWithBlock把任务添加到队列1======%@", [NSThread currentThread]);
        }
    }];
    
    // 添加操做到队列
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"addOperationWithBlock把任务添加到队列2======%@", [NSThread currentThread]);
        }
    }];
    
    // 添加操做到队列
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"addOperationWithBlock把任务添加到队列3======%@", [NSThread currentThread]);
        }
    }];
}
复制代码

运行结果以下，当最大并发数为1的时候，虽然开启了线程，可是任务是顺序执行的，因此实现了串行。 你能够尝试把上面的最大并发数变为2，会发现任务就变成了并发执行。

addOperationWithBlock把任务添加到队列1======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任务添加到队列1======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任务添加到队列1======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任务添加到队列2======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任务添加到队列2======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任务添加到队列2======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任务添加到队列3======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任务添加到队列3======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任务添加到队列3======<NSThread: 0x608000068980>{number = 3, name = (null)}
复制代码

No.5：NSOperation的其余操做

  • 取消队列NSOperationQueue的全部操做，NSOperationQueue对象方法
- (void)cancelAllOperations
复制代码
  • 取消NSOperation的某个操做，NSOperation对象方法
- (void)cancel
复制代码
  • 使队列暂停或继续
// 暂停队列
[queue setSuspended:YES];
复制代码
  • 判断队列是否暂停
- (BOOL)isSuspended
复制代码

暂停和取消不是马上取消当前操做，而是等当前的操做执行完以后再也不进行新的操做。

No.6：NSOperation的操做依赖

NSOperation有一个很是好用的方法，就是操做依赖。能够从字面意思理解：某一个操做（operation2）依赖于另外一个操做（operation1），只有当operation1执行完毕，才能执行operation2，这时，就是操做依赖大显身手的时候了。

- (void)testAddDependency {
    
    // 并发队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    
    // 操做1
    NSBlockOperation *operation1 = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"operation1======%@", [NSThread  currentThread]);
        }
    }];
    
    // 操做2
    NSBlockOperation *operation2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"****operation2依赖于operation1，只有当operation1执行完毕，operation2才会执行****");
        for (int i = 0; i < 3; i++) {
            NSLog(@"operation2======%@", [NSThread  currentThread]);
        }
    }];
    
    // 使操做2依赖于操做1
    [operation2 addDependency:operation1];
    
    // 把操做加入队列
    [queue addOperation:operation1];
    [queue addOperation:operation2];
}
复制代码

运行结果以下，操做2老是在操做1以后执行，成功验证了上面的说法。

operation1======<NSThread: 0x60800026dec0>{number = 3, name = (null)}
operation1======<NSThread: 0x60800026dec0>{number = 3, name = (null)}
operation1======<NSThread: 0x60800026dec0>{number = 3, name = (null)}
****operation2依赖于operation1，只有当operation1执行完毕，operation2才会执行****
operation2======<NSThread: 0x60800026dc80>{number = 4, name = (null)}
operation2======<NSThread: 0x60800026dc80>{number = 4, name = (null)}
operation2======<NSThread: 0x60800026dc80>{number = 4, name = (null)}
复制代码

后记

本文所述的示例代码在这里：WHMultiThreadDemo

github地址：github.com/remember17

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程