iOS多线程

写一下iOS多线程的相关知识，多线程无论是在实际开发中还是在面试的时候都是相关重要的一个知识点，特别是GCD和NSOperation，现在做一下总结，加深一下对多线程的理解。

概述

在此，我就不说什么是多线程、线程和进程的区别、多线程有什么作用、还有串行和并行的相关内容，主要说NSThreads、GCD、NSOperation和NSOperationQueue的使用方法和一些案例，其实除了上面三套线程方案外，还有一个Pthreads，在类Unix操作系统，都使用Pthreads作为操作系统的线程，我是没用过，就不再这班门弄斧了，大家自行查资料。

NSThread

这方案是苹果封装后的，并完全面向对象的，可以直接操控线程对象，非常直观和方便，但它的生命周期需要我们手动管理，这个方案也是偶尔调试用用（[NSThread currentThread]），获取当前线程类，可以看到当前线程的各种属性。

创建并启动

先创建线程类->启动
OC

NSThread * thread = [[NSThread alloc] initWithTarget:self selector:@selector(eat:) object:nil];

[thread start];

//创建并自动启动
[NSThread detachNewThreadSelector:@selector(eat:) toTarget:self withObject:nil];

Swift

let thread = Thread(target: self, selector: #selector(eat), object: nil)
        
thread.start()

// 创建并自动启动
Thread.detachNewThreadSelector(#selector(eat), toTarget: self, with: nil)

还有一些常见的方法

// 取消线程
[thread cancel];
    
// 获取当前线程信息
[NSThread currentThread];
    
// 获取主线程信息
[NSThread mainThread];

其实，NSThread用起来很简单，方法比较少，也只会在一些简单的场景才会用这个，不能优雅地处理多线程中的其他高级概念。接下来要说的就是比较重点的了。

GCD

Grand Central Dispatch，是苹果为多核的并行运算提出的解决方案，会自动合理地利用更多CPU内核，最重要的是会自动管理线程的生命周期（创建线程、调度任务和销毁线程），不需要我们管理，只需要告诉干什么就行，GCD使用的是C语言，由于使用了Block，使用起来很方便，这个也是我用的最多的一种方案。

任务和队列

在GCD中，加入了两个很重要的概念：任务和队列。

任务：就是要干什么，在此就是一个Block，任务有两种执行方式：同步执行和异步执行，区别是是否会阻塞当前线程，知道任务执行完毕。

同步执行：会阻塞当前线程并等待Block中的任务执行完毕，然后当前线程才会继续往下运行。
异步执行：会直接往下执行，不会阻塞当前线程。

队列：用于存放任务。有串行队列和并行队列
串行队列的任务会根据队列的定义FIFO执行，也就是取一个出来，执行一个，然后再取一个出来，一个一个执行。
并行队列也会FIFO执行，不同的是，它取出来一个会放到别的线程，然后再取一个又放到另一个线程，取的动作很快，看起来都是一起执行的。

创建队列

主队列：这是一个特殊的串行队列。用于刷新UI，任何需要刷新UI的工作都要在主队列执行，所以一般耗时的任务都要放在别的线程执行。

// OC
dispatch_queue_t queue = dispatch_get_main_queue();

// Swift
let queue = dispatchMain()

自己创建的队列： 第一个参数是标识符，用于DEBUG的时候标识唯一的队列，可以为空，第二个参数传入 DISPATCH_QUEUE_SERIAL 或 NULL 标识创建串行队列。传入 DISPATCH_QUEUE_CONCURRENT 标识创建并行队列。

OC
// 串行队列
dispatch_queue_t queue1 = dispatch_queue_create("FIRSTQUEUE", NULL);
dispatch_queue_t queue2 = dispatch_queue_create("SECONDQUEUE", DISPATCH_QUEUE_SERIAL);
// 并行队列
dispatch_queue_t queue3 = dispatch_queue_create("THIRDQUEUE", DISPATCH_QUEUE_CONCURRENT);
Swift
// 串行队列
let queue1 = DispatchQueue(label: "serialQueuel")
        
// 并行队列
let queue2 = DispatchQueue(label: "concurrentQueuel", qos: .default, attributes: .concurrent, autoreleaseFrequency: DispatchQueue.AutoreleaseFrequency.never, target: nil)

全局并行队列： 只要是并行任务一般都加入到这个队列。这是系统提供的一个并发队列。

OC
dispatch_queue_t queue4 = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
Swift
let queue3 = DispatchQueue.global(qos: .default)

创建任务

同步任务：会阻塞当前线程（sync）
Objective-C

dispatch_queue_t queue3 = dispatch_queue_create("THIRDQUEUE", DISPATCH_QUEUE_CONCURRENT);
dispatch_sync(queue3, ^{
        NSLog(@"%@",[NSThread currentThread]);
    });

Swift

let queue2 = DispatchQueue(label: "concurrentQueuel", qos: .default, attributes: .concurrent, autoreleaseFrequency: DispatchQueue.AutoreleaseFrequency.never, target: nil)

queue2.sync {
            print(Thread.current)
        }

异步任务：不会阻塞当前线程（async）
Objective-C

dispatch_queue_t queue3 = dispatch_queue_create("THIRDQUEUE", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue3, ^{
        NSLog(@"%@",[NSThread currentThread]);
    });

Swift

let queue2 = DispatchQueue(label: "concurrentQueuel", qos: .default, attributes: .concurrent, autoreleaseFrequency: DispatchQueue.AutoreleaseFrequency.never, target: nil)

queue2.async {
            print(Thread.current)
        }

为了更好理解同步和异步，举两个栗子：
eg1:

NSLog(@"当前线程 --- %@",[NSThread currentThread]);
    
dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"同步 --- %@",NSThread.currentThread);
    });
NSLog(@"现在线程 --- %@",NSThread.currentThread);

MultithreadingOC[1071:46482] 当前线程 --- <NSThread: 0x604000063680>{number = 1, name = main}

崩溃啦

很尴尬，打印完第一句之后，卡死在block那里了，为什么会这样呢？
Answer
同步任务会阻塞当前线程，然后把Block中的任务放到指定的队列中执行，只能等Block中的任务完成才能继续往下运行，在打印了第一句之后，dispatch_sync 立即阻塞了主线程，Block中的任务放到main中，可是main中的任务会被取出来放到主线程中执行，但主线程这个时候已经被阻塞了，所以Block中的任务就不能完成，然后就会一直阻塞主线程，出现死锁现象。
eg2:

print("之前 - \(Thread.current)")
        
let queue = DispatchQueue(label: "SERIAL")
queue.async {
            print("sync之前 - \(Thread.current)")
            queue.sync(execute: {
                print("sync - \(Thread.current)")
            })
            print("sync之后 - \(Thread.current)")
}
        
print("之后 - \(Thread.current)")

输出如下：

之前 - <NSThread: 0x604000077940>{number = 1, name = main}
sync之前 - <NSThread: 0x604000274100>{number = 3, name = (null)}
之后 - <NSThread: 0x604000077

其中有两条打印信息没有被打印，接下来，我们分析一下：

首先我们创建了一个串行队列。
‘dispatch_async’ 是异步操作，所以不像第一个例子那样阻塞当前线程，开辟了多一条线程，一条当前线程继续往下打印了‘之后 - ’那句，另一条执行Block中的内容，打印了‘sync之前 - ’那句，应为是并行，所以打印顺序先后是无所谓的。
但是，中间那里，‘dispatch_sync’ 同步执行了，‘sync’ 把Block 的任务放到 ‘queue’ 中，可队列是串行队列，一次执行一个任务，可 ‘queue’ 被 ‘sync’ 阻塞了，又发生死锁了，所以不会打印里面两句代码。

队列组

队列组可以将很多队列添加到一个组里，当这个组里所有任务执行完了，队列组会通过一个方法通知我们。
Objective-C

// 1. 创建队列组
dispatch_group_t group = dispatch_group_create();
// 2. 创建队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
// 3. 多次使用队列组的方法执行任务，只有异步方法
// 3.1 执行3次循环
dispatch_group_async(group, queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"group - %@",[NSThread currentThread]);
        }
});
    
// 3.3 执行5次循环
dispatch_group_async(group, queue, ^{
        for (int i = 0; i < 5; i++) {
            NSLog(@"group - %@",[NSThread currentThread]);
        }
});
    
// 4. 都完成了自动通知
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        NSLog(@"end - %@",NSThread.currentThread);
});

Swift

let group = DispatchGroup()
let queue = DispatchQueue.global()
        queue.async(group: group) {
            for _ in 0..<3 {
                print("group1 - \(Thread.current)")
            }
}
          
queue.async(group: group) {
            for _ in 0..<5 {
                print("group2 - \(Thread.current)")
            }
}
        
group.notify(queue: DispatchQueue.main) {
            print("end - \(Thread.current)")
}

以上就是GCD的基本功能，但它的能力远不止这些，讲完NSOperation后，在看其他一些用途。

NSOperation&NSOperationQueue

NSOperation是苹果对GCD的封装，完全面向对象，用起来更好理解。

添加任务

NSOperation是一个抽象类，不能封装任务，但它有两个子类用于封装任务。分别是：NSInvocationOperation和NSBlockOperation。创建Operation后，需要调用start方法来启动任务，会默认在当前队列同步执行。也可以中途取消任务，调用cancel即可。

NSInvocationOperation:需要传入一个方法名。

NSInvocationOperation * operation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(run) object:nil];
[operation start];

在Swift中，NSInvocationOperation不是ARC-safe,所以不支持。

NSBlockOperation
OC

// 1. 创建NSBlockOperation
NSBlockOperation * operation = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"%@",[NSThread currentThread]);
}];
// 2. 开始任务
[operation start];

Swift

// 1. 创建BlockOperation
let operation = BlockOperation {
       print(Thread.current)
}
        
// 2. 开始任务
operation.start()

上面说了，这样创建任务，会默认在当前线程执行。但是NSBlockOperation还有一个方法addExecutionBlock: ,同个这个方法可以给Operation添加多个执行Block,这样Operation中的任务会并发执行。

NSBlockOperation * operation = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"%@",NSThread.currentThread);
    }];
    
[operation addExecutionBlock:^{
        NSLog(@"Other - %@",NSThread.currentThread);
}];
    
[operation start];

Swift

// 1. 创建BlockOperation
let operation = BlockOperation {
            print(Thread.current)
}
        
operation.addExecutionBlock {
            print("Other - \(Thread.current)")
}
        
// 2. 开始任务
operation.start()

注意：addExecutionBlock必须在start之前执行，否则会报错。

自定义Operation
除了上面两种Operation外，我们还可以自定义Operation。自定义Operation需要继承NSOperation类，并实现main()方法，因为在调用start()方法的时候，内部会调用main()方法完成相关逻辑。除此之外，还需要实现cancel()在内的各种方法。

创建队列

上面用NSOperation启动任务默认是同步的，就算用addExecutionBlock方法，也会在当前线程和其他线程中执行，还是会占用当前线程，这就要用到NSOperationQueue了。

主队列

// OC
NSOperationQueue * queue = [NSOperationQueue mainQueue];
// swift
let queue = OperationQueue.main

其他队列
OC

// 1. 创建一个队列
NSOperationQueue * queue = [[NSOperationQueue alloc] init];
// 2. 创建NSBlockOperation对象
NSBlockOperation * operation = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"%@",NSThread.currentThread);
}];
    
[operation addExecutionBlock:^{
        NSLog(@"%@",NSThread.currentThread);
        
}];
    
// 3. 队列添加任务
[queue addOperation:operation];

Swift

let queue = OperationQueue()
        
let operation = BlockOperation {
            print("--- \(Thread.current)")
}
        
operation.addExecutionBlock {
            print("\(Thread.current) ---")
}
        
queue.addOperation(operation)

对比GCD会发现，串行队列找不到了，那怎么办呢？
NSOperationQueue有一个参数maxConcurrentOperationCount最大并发数，可以设置多少个任务同时执行，我们把它设为1，那想不串行都不行了。

NSOperation有一个很实用的功能，就是添加依赖。例如：1：从服务器download一张图片，2：对图片进行加水印，3：把图片upload到服务器
OC

NSBlockOperation * operationOne = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"download - %@",[NSThread currentThread]);
        [NSThread sleepForTimeInterval:1.0];
}];
    
NSBlockOperation * operationTwo = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"add - %@",[NSThread currentThread]);
        [NSThread sleepForTimeInterval:1.0];
}];
    
NSBlockOperation * operationThree = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"upload - %@",[NSThread currentThread]);
        [NSThread sleepForTimeInterval:1.0];
}];
    
// 设置依赖
[operationTwo addDependency:operationOne];
[operationThree addDependency:operationTwo];
    
// 创建队列加入任务
NSOperationQueue * queue = [[NSOperationQueue alloc] init];
[queue addOperations:@[operationThree, operationTwo, operationOne] waitUntilFinished:NO];

Swift

let operationOne = BlockOperation {
            print("download - \(Thread.current)")
            Thread.sleep(forTimeInterval: 1.0)
}
        
let operationTwo = BlockOperation {
            print("add - \(Thread.current)")
            Thread.sleep(forTimeInterval: 1.0)
}
        
let operationThree = BlockOperation {
            print("upload - \(Thread.current)")
            Thread.sleep(forTimeInterval: 1.0)
}
        
operationTwo.addDependency(operationOne)
operationThree.addDependency(operationTwo)
        
let queue = OperationQueue()
queue.addOperations([operationThree, operationTwo, operationOne], waitUntilFinished: false)

输出

2018-04-12 17:14:29.523538+0800 MultithreadingOC[4136:252621] download - <NSThread: 0x600000263ec0>{number = 3, name = (null)}
2018-04-12 17:14:30.526059+0800 MultithreadingOC[4136:252621] add - <NSThread: 0x600000263ec0>{number = 3, name = (null)}
2018-04-12 17:14:31.527632+0800 MultithreadingOC[4136:252619] upload - <NSThread: 0x604000279580>{number = 4, name = (null)}

要注意的是不能互相依赖，会死锁，可以通过removeDependency来接触依赖关系。

以上就是NSOperation的一些基本用法，接下来说一下关于多线程的一些应用，尽量用多种方法实现以下。

单例模式

什么是单例，我就不多说了，直入主题
Objective-C

@implementation Single

static id _instance;

+ (instancetype)sharedSingle{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        _instance = [[Single alloc] init];
    });
    return _instance;
}

@end

Swift

import UIKit

class Single: NSObject {

    static let sharedSingle = Single()
    
    private override init() {
        
    }
}

延迟执行

延时一段时间再执行某段代码。

// perform
[self performSelector:@selector(run:) withObject:@"123" afterDelay:3];
    
// GCD
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), queue, ^{
        
});
    
// NSTimer
[NSTimer scheduledTimerWithTimeInterval:3.0 repeats:YES block:^(NSTimer * _Nonnull timer) {
        
}];

线程同步

线程同步是为了防止多个线程抢夺同一个资源造成的数据安全问题。

互斥锁：给需要同步的代码块加一个互斥锁，可以保证每次只有一个线程访问此代码块。

OC
- (void)run{
    @synchronized(self) {
        // 需要执行的代码块
    }
}

Swift
@objc func eat() {
        objc_sync_enter(self)
        // 需要执行的代码块
        objc_sync_exit(self)
}

同步执行：将多个线程都要执行此段代码添加到同一个串行队列，就可以实现线程同步了。

GCD
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_sync(queue, ^{

});
 
NSOperation   
NSBlockOperation * operation = [NSBlockOperation blockOperationWithBlock:^{
        
}];
NSOperationQueue * queue = [[NSOperationQueue alloc] init];
[queue addOperation:operation];
queue.maxConcurrentOperationCount = 1;
[operation waitUntilFinished];

总结一下

写了两天，写的都是一些比较基础的东西，Swift版本和OC版本差别不是特别大，，但是关于多线程的东西还远不止于此，以后用到其他的方法会继续更新上去的~~~

最后编辑于：2018.04.13 16:22:57

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

iOS多线程

概述

NSThread

创建并启动

GCD

任务和队列

创建队列

创建任务

队列组

NSOperation&NSOperationQueue

添加任务

创建队列

单例模式

延迟执行

线程同步

总结一下

推荐阅读更多精彩内容