什么是进程？

最通俗的描述就是一个个pid,官方的说法：进程是程序在计算机上的一次执行活动。打开一个app 就开启了一个进程。可包含多个线程。

什么是线程？

独立执行的代码段，一个线程同一时间内只能执行一个任务，反之多线程并发就可以在同一时间执行多个任务。

同步和异步

一个同步函数只在完成了预定任务后才返回。会阻塞当前线程。异步时任务开启会立即返回，不阻塞当前线程去执行下一个函数。异步会开启其他线程。

串行和并发

串行：任务按先后顺序逐个执行。并发：后面的任务不会等前面的任务完成了再执行，同样会遵循先添加先执行的原则，但添加间隔往往忽略不计。所以看上去像是一起执行。

并发与并行

并发和并行通常被一起提到，所以值得花些时间解释它们之间的区别。

并发代码的不同部分可以“同步”执行。然而，该怎样发生或是否发生都取决于系统。多核设备通过并行来同时执行多个线程；然而，为了使单核设备也能实现这一点，它们必须先运行一个线程，执行一个上下文切换，然后运行另一个线程或进程。这通常发生地足够快以致给我们并发执行地错觉，如下图所示：

虽然你可以编写代码在 GCD 下并发执行，但 GCD 会决定有多少并行的需求。并行要求并发，但并发并不能保证并行。

什么是GCD？

GCD 是一套低层API，用于将任务切分成单一任务提交至队列并发或者串行执行。遵循FIFO 原则，先提交到队列的先执行。串行队列和并发队列都是如此。

串行队列

串行队列中的任务一次执行一个，每个任务只在前一个任务完成时才开始。而且，你不知道在一个 Block 结束和下一个开始之间的时间长度，如下图所示：

并发队列

在并发队列中的任务能得到的保证是它们会按照被添加的顺序开始执行，但这就是全部的保证了。任务可能以任意顺序完成，你不会知道何时开始运行下一个任务，或者任意时刻有多少 Block 在运行。再说一遍，这完全取决于 GCD 。

下图展示了一个示例任务执行计划，GCD 管理着四个并发任务：

GCD基本队列类型

1. Main quene

主线程队列，串行，可以通过dispatch_get_main_quene() 获取。UI操作都需要在主线程中执行。

1. Global quene

系统提供的并发队列。通过dispatch_get_global_queue 创建。

1. Custom quene

自定义队列，可以为串行，也可为并发。通过dispatch_queue_create 创建。

队列组

将多线程进行分组，最大的好处是可获知所有线程的完成情况。当多线程并发执行时，由于单个线程什么时候结束并不知道，所以很难判断线程组整个完成情况，通过dispatch_group_notify，可以直接监听组里所有线程完成情况。

常规用法

1. Global quene 及 Custom quene（创建串行队列）

1.1 并发队列，异步执行

此处为直接使用global_quene

    override func viewDidLoad() {
        super.viewDidLoad()
        // 并发队列，异步执行
        for index in 1...5 {
            dispatch_async(dispatch_get_global_queue(0, 0), { () -> Void in
                //                println("currentIndex----\(index)")
                NSLog("currentIndex:----\(index), thread:---%@",NSThread.currentThread())
            })
        }
        NSLog("主线程,thread:---%@",NSThread.currentThread())
    }

NSLog打印结果为：

可看到执行完成为无序的，而且每次都不一样。同样也能看到出主线程外，另外开启了5个线程。 注意此处用的是NSLog 输出，而不是Println。因为NSLog 本身是同步的，而Println 为异步，在多线程并发调用时Println 输出结果会错乱。

1.2 并发队列，同步执行

还是上面的例子，紧改为同步执行dispatch_sync

    override func viewDidLoad() {
        super.viewDidLoad()
        // 并发队列，同步执行
        for index in 1...5 {
            dispatch_sync(dispatch_get_global_queue(0, 0), { () -> Void in
                //                println("currentIndex----\(index)")
                NSLog("currentIndex:----\(index), thread:---%@",NSThread.currentThread())
            })
        }
        NSLog("主线程,thread:---%@",NSThread.currentThread())
    }

打印结果为：

可看到并没有开启其他线程，任务按顺序逐个执行，同时阻塞主线程。搞不懂这种“并发队列，同步执行”的意义所在。

1.3 串行队列，异步执行

使用dispatch_quene_creat 创建串行队列

    override func viewDidLoad() {
        super.viewDidLoad()
        // 串行队列，异步执行
        var quene  = dispatch_queue_create("1", DISPATCH_QUEUE_SERIAL)// 创建串行队列
        for index in 1...5 {
            dispatch_async(quene, { () -> Void in
                //                println("currentIndex----\(index)")
                NSLog("currentIndex:----\(index), thread:---%@",NSThread.currentThread())
            })
        }
        NSLog("主线程,thread:---%@",NSThread.currentThread())
    }

打印结果为：

可以看到另外开启了一个线程，不会将主线程阻塞，任务按顺序执行。

1.4 串行队列，同步执行

使用dispatch_quene_creat 创建串行队列

    override func viewDidLoad() {
        super.viewDidLoad()
        // 串行队列，同步执行
        for index in 1...5 {
            dispatch_sync(quene, { () -> Void in
                //                println("currentIndex----\(index)")
                NSLog("currentIndex:----\(index), thread:---%@",NSThread.currentThread())
            })
        }
        NSLog("主线程,thread:---%@",NSThread.currentThread())
    }

打印结果为： 可看到不会开启其他线程，会阻塞主线程，任务按顺序执行。

1.5 Custom quene 创建并发队列

还是一样的例子，只不过改为

        var quene  = dispatch_queue_create("1"，DISPATCH_QUEUE_CONCURRENT)// 创建并发队列

可看到异步，同步执行结果与1.1 和1.2 一样。就不一一列出了。

1. Main quene 使用，线程死锁

想必这个应该都知道怎么用，在其他线程中回到主线程，去执行ui操作。注意是在其他线程中获取主线程。所以要注意以下问题。

2.1 不要在主线程中获取主线程队列，并同步执行任务。

    override func viewDidLoad() {
        dispatch_sync(dispatch_get_main_queue(), { () -> Void in
            NSLog("在主线程执行任务")
        })
    }

这种写法一定会线程死锁。同步执行首先就阻塞了主线程，然后又想在主线程去执行任务所以任务没法完成，任务没法完成又导致了线程没法结束。所以导致了恶性循环，主线程就一直这么阻塞着。导致UI一直卡住。

1. 队列组

3.1 使用场景

个人觉得先要知道什么时候需要使用到队列组。队列组一般配合dispatch_group_notify 使用，用于监听这一组任务是否全部完成。所以使用场景为：

你要有多个任务，如果是单个任务的情况，根本没有必要使用队列组。
而且还要是异步执行的情况，若是同步阻塞在那执行完了自然知道。

同时也不要认为队列组就会有很多队列，其实不是，队列组其实是要实现的是对线程所有任务的分组监听，所以只有一个队列也可以

3.1.1异步执行，串行队列组

    override func viewDidLoad() {
        super.viewDidLoad()
        var group = dispatch_group_create()
        var quene = dispatch_queue_create("1", DISPATCH_QUEUE_SERIAL)//串行队列

        dispatch_group_notify(group, quene) { () -> Void in
            dispatch_async(dispatch_get_main_queue(), { () -> Void in
                NSLog("任务结束，回到主线程")
            })
        }
        for index in 1...5 {
            dispatch_group_async(group, quene, { () -> Void in
                NSLog("currentIndex:----\(index), thread:---%@",NSThread.currentThread())
            })
        }
        NSLog("主线程")
    }

打印结果为：

可看到除主线程外，有其他一个线程，串行任务结束后能够实时监听到，回到主线程。

3.1.2异步执行，并发队列组

    override func viewDidLoad() {
        super.viewDidLoad()
        var group = dispatch_group_create()
        var quene = dispatch_queue_create("1", DISPATCH_QUEUE_CONCURRENT)//并发队列，也可以用global_quene
        dispatch_group_notify(group, quene) { () -> Void in
            dispatch_async(dispatch_get_main_queue(), { () -> Void in
                NSLog("任务结束，回到主线程")
            })
        }
        for index in 1...5 {
            dispatch_group_async(group, quene, { () -> Void in
                NSLog("currentIndex:----\(index), thread:---%@",NSThread.currentThread())
            })
        }
        NSLog("主线程")
    }

打印结果为：

同样所有线程的任务全部结束后，能监听到，通知主线程。

写在最后

本文凭借个人理解，同时也参考了不少博客。列举了GCD的一些常规用法，还有很多特性没有一一列出。不熟的知识点不敢乱写，以后再慢慢完善。iOS 多线程也不仅仅是GCD 这一种，但我觉得最好用的还是GCD。觉得有用就打赏，点赞，同时有错误忘指正...

文章转载自 开源中国社区[https://www.oschina.net]