IOS 进程、主线程、主队列（巴哥莫出品）

author ：巴哥莫 https://www.jianshu.com/u/a64ad02ab496

调试环境：Mac mojave 10.14.1 + Xcode10 + Swift4.0

关键字：进程、线程、主线程、子线程、队列、、主队列、global队列、main函数、Runloop

文集：IOS- Swift-启动篇

章节：启动

编号：1.0.0

写作时间：2018-12-05

本文地址 : https://www.jianshu.com/p/75490b41cde3

前言

笔者本着一个从业多年OC开发的码农，最近兴致好，想学习一下Swift并写点东西当作笔记。原本以为这是个很简单的事情，不就是把OC代码翻译一遍吗？有什么难的，写的时候才发现，把话讲明白似乎没那么容易。

内容概述

进程和线程概念复习

C&OC main启动

主线程&子线程

主队列

进程和线程概念复习

巴哥去请教了公司C语言的同事，同时也查了一些资料，先引入几个概念的东西线程进程简单描述

进程
是具有一定独立功能的程序，相对操作系统来说，操作系统分配资源给进程，所以进程作为系统资源分配和调度的基本单位，进程是可以独立运行的一段程序。

线程
线程进程的一个实体，是CPU调度和分派的基本单位，他是比进程更小的能独立运行的基本单位。相对于进程，线程拥有系统资源比较少，而且线程的生命周期是进程这个程序来控制的。在运行时，只是暂用一些计数器、寄存器和栈。同时一个进程至少要有一个主线程。所以真正执行任务的是线程。

关于进程和线程，网上的说法五花八门，巴哥复制了一段，供大家参考，下面这段话是我的一个同事告诉我的，他让我深刻理解，我也贴出来供大家参考
进程是拥有资源的最小单位。线程是执行的最小单位。 --- 某C语言同事

main 启动

C 语言代码 main

int main(){
    while (1) {
        printf("pid is %d \n",getpid());
    }
    return 0;
}

result:

pid is 78743
pid is 78743
pid is 78743
……

-

1543979065578.jpg

在进入main的时候进程和主线程就已经存在了

应用程序进程启动的时候主线程被系统创建了，应用程序是需要不断的和用户进行交互的，即主线程是需要一直存在。main函数在执行到return 的时候进程就会被销毁，线程也会被释放。很显然，应用程序的main函数是不会主动返回的。

主线程常驻

应用程序是需要一个长久存在的线程，这个线程通常被我们称作为主线程，主线程如何常驻？（上一小节中通过while循环可以让主线程长期存活，但是这种方式不可取）应用程序都是响应式的机制，例如，点击，触摸，外部进程抢占资源 …… ，应用程序需要快速的对这些事件进行相应。

oc main函数代码

int main(int argc, char * argv[]) {
    @autoreleasepool {
        return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
    }
}

swift没有暴露main方法他是使用了@UIApplicationMain ，两者内部实现是一样的。（OC的比较直观，直接用OC代码做例子）
UIApplicationMain 函数做了什么，我们从他的函数申明来分析一下？
UIKIT_EXTERN int UIApplicationMain(int argc, char * _Nullable argv[_Nonnull], NSString * _Nullable principalClassName, NSString * _Nullable delegateClassName);
四个参数
@param argc C main函数参数不再复述
@param argv C main函数参数不再复述
@param principalClassName 一个字符串类型的参数principalClassName，直译为主要类，必须为UIApplication或者其子类，代表着当前app自身。并且如果此参数为nil的话，则默认为@"UIApplication"
@param delegateClassName 代理类。在UIApplication中有个delegate的变量，delegate遵守UIApplicationDelegate协议负责程序的生命周期。UIApplication 接收到所有的系统事件和生命周期事件时，都会把事件传递给UIApplicationDelegate进行处理

综上所述：UIApplicationMain做了如下3件事

创建了UIApplication或其子类的对象

根据传入第四个参数创建了代理对象并设置UIApplication的代理为刚刚创建出来的代理对象

应用程序需要main线程常驻，并且还要是响应式的，所以UIApplication在创建的时候应该还做了一件事，启动了Runloop。（Runloop是怎么做到不堵塞主线程并且快速响应，下一章节将会作介绍）

主线程VS子线程

按照某C语言同事的说法（进程是拥有资源的最小单位。线程是执行的最小单位）进程应该是资源空间以及资源空间下线程的总和。传统意义上的主线程应该叫第一个线程，只不过其他线程的建立是依赖于第一个线程，既然线程是执行的最小单位，CPU在分配时间片段给线程的时候应该是雨露均沾的，而不是分主次的。虽然第一个线程在创建时先于其他的线程，但是他们一旦创建了，CPU在调度的时候应该平等。

思考：？？对于整个操作系统而言，线程之间是否的平等的

主线程

主线程通常又叫UI线程。为什么和UI相关的东西都要放在主线程中执行？为什么在子线程中去做UI的操作会经常出现Bug？

    @IBAction func doDownLoadAction(_ sender: Any) {
        DispatchQueue.global().async {
            [unowned self] in
            self.imageView.image = UIImage(named: "image1.png");
        }
    }

result: 虽然程序没有崩溃，但是在控制台上还是报了警告信息，并且这个图片加载的很慢或根本就加载不出来。（子线程在给UI赋值的时候其实值已经传成功，只是没有机制去触发UI的更新）

Main Thread Checker: UI API called on a background thread: -[UIImageView setImage:]

从OCmain的启动函数中可以看出，子线程和主线程宏观上的区别就是主线中添加了Runloop ，Runloop使得主线程一致存在，不会退出。假如我们在子线程中也添加一个Runloop，情况会是什么样的呢？

@IBOutlet weak var imageView: UIImageView!
    var subThread:Thread!;
    override func viewDidLoad() {
        super.viewDidLoad();
        subThread = Thread.init(target: self, selector: #selector(makeSubThreadAlive), object: nil)
        subThread.name = "subThread";
        subThread.start();
    }
    @IBAction func doSubThreadTask(_ sender: Any) {
        self .perform(#selector(refreashImage), on: subThread, with: nil, waitUntilDone: false)
    }
    @objc func refreashImage(){
        self.imageView.image = UIImage(named: "image1.png");
        //Thread.sleep(forTimeInterval: 5);
    }
    @objc func makeSubThreadAlive(){
        print("runloop start");
        let machPort = NSMachPort();
        RunLoop.current.add(machPort, forMode: RunLoop.Mode.default);
        RunLoop.current.run();
        print("runloop end")
    }

result:虽然依然会有警告，但是图片刷新正常了，很显然是Runloop触发了图片控件的更新

Main Thread Checker: UI API called on a background thread: -[UIImageView setImage:]

思考：？？是不是表示如果开启一个常驻的子线程，就可以通过该子线程来更新UI?
当然还是在主线程中去更新UI比较好。巴哥通过这个例子告诉大家，其实主线程没有那么神秘，它和其他的线程之间是平等的，只不过UIApplication在初始化的时候在主线程中启动一个Runloop（Runloop 巴哥计划也开个章节写一写，因为这个很重要）

主队列

队列概念
队列像栈一样，是一种线性表，它的特性是先进先出，插入在一端，删除在另一端。就像排队一样，刚来的人入队（push）要排在队尾(rear)，每次出队(pop)的都是队首(front)的人

队列特点
队列中的数据元素遵循“先进先出”（First In First Out）的原则，简称FIFO结构。
在队尾添加元素，在队头删除元素。

主队列的获取

DispatchQueue.main
OperationQueue.main;

主队列的获取是通过类变量获取的，这说明主队列是事先分配好的

Question:队列就是队列，为什么要强行提个概念叫主队列呢？

队列和线程

主队列运行在主线程中吗？iOS主线程和主队列的区别
备注：线程就是线程，队列就是队列，这两者概念上应该是清晰的（没有可比性，叫做联系或则关系比较准确），只不过队列是运行在线程上的

DispatchQueue.main.async {
     print("2222 \(Thread.main)");
}

result: 主队列运行在主线程中，它只是被默认取了个名字叫 main 真实的名字叫做 com.apple.main-thread

2222 <NSThread: 0x282678b00>{number = 1, name = main}

func doSomeThingInCommonQueue(){
        let queue = DispatchQueue.init(label: "aaa");
        queue.sync {
            print("queue run in \(Thread.current)");
            self.imageView.image = UIImage(named: "image1.png");
        }
    }

result: 启动一个队列使用同步方式，它运行的线程是主线程，并且界面刷新正常。

queue run in <NSThread: 0x28233edc0>{number = 1, name = main}

队列是平等的，自定义的队列在主线程中运行也能起到主队列的作用，主队列只不过是一种约定俗成的概念，默认将系统帮我们建立的这个取名为main的队列叫做主队列

巴哥浅见iOS主线程和主队列的区别

这篇文章中的例子很好，巴哥谈谈对这几个例子的理解。

import Foundation
print("Hello, World!")
debugPrint("current thread out: \(Thread.current)") //主线程在这里呢 看我的number编号
let key = DispatchSpecificKey<String>()
let queueGlobal =  DispatchQueue.global();
let globalKey = DispatchSpecificKey<String>();
DispatchQueue.main.setSpecific(key: key, value: "main")
DispatchQueue.global().setSpecific(key: globalKey, value: "global");
func log() {
    debugPrint("main thread: \(Thread.isMainThread)")
    debugPrint("current thread in: \(Thread.current)")
    let valueglobal = DispatchQueue.global().getSpecific(key: key);
    print("从globalqueue中取queue key 为  main 是否能取到  \(String(describing: valueglobal))");
    let valuemain = DispatchQueue.main.getSpecific(key: key);
    print("从main queue中取queue key 为  main \(String(describing: valuemain))");
    let value = DispatchQueue.getSpecific(key: key)
    print("\(String(describing: value))");
    debugPrint("main queue: \(value != nil)")
    let globalValue = DispatchQueue.getSpecific(key: globalKey);
    debugPrint("global queue: \(globalValue != nil)")
}
DispatchQueue.global().sync(execute: log)
RunLoop.current.run()// result2 会屏蔽它

result1: 启动RunLoop （getSpecific这个函数的解释巴哥会在GCD章节中介绍）

Hello, World!
"current thread out: <NSThread: 0x100f0bbc0>{number = 1, name = main}"
"main thread: true"
"current thread in: <NSThread: 0x100f0bbc0>{number = 1, name = main}"
从globalqueue中取queue key 为  main 是否能取到  nil
从main queue中取queue key 为  main Optional("main")
nil
"main queue: false"
"global queue: true"

result2: 不启动RunLoop，Program ended with exit code: 0 进程退出了

Hello, World!
"current thread out: <NSThread: 0x100f0bbc0>{number = 1, name = main}"
"main thread: true"
"current thread in: <NSThread: 0x100f0bbc0>{number = 1, name = main}"
从globalqueue中取queue key 为  main 是否能取到  nil
从main queue中取queue key 为  main Optional("main")
nil
"main queue: false"
"global queue: true"
Program ended with exit code: 0

上文中巴哥提到，不要把主线程看的很特殊，应用程序中主线程只不过是在线程 number = 1的线程上启动了RunLoop ，让这个number = 1的线程常驻，RunLoop启动后会让这个number = 1的线程有响应机制。

sync 不会启动新的线程，所以结果中当前线程是在number = 1的线程上执行

DispatchQueue.getSpecific(key: key) 这个类方法不是表示从全局获取名字叫做key的队列

如果global queue使用异步执行

import Foundation
print("Hello, World!")
debugPrint("current thread out: \(Thread.current)") //主线程在这里呢 看我的number编号
let key = DispatchSpecificKey<String>()
let queueGlobal =  DispatchQueue.global();
let globalKey = DispatchSpecificKey<String>();
DispatchQueue.main.setSpecific(key: key, value: "main")
DispatchQueue.global().setSpecific(key: globalKey, value: "global");
func log() {
    debugPrint("main thread: \(Thread.isMainThread)")
    debugPrint("current thread in: \(Thread.current)")
    let valueglobal = DispatchQueue.global().getSpecific(key: key);
    print("从globalqueue中取queue key 为  main 是否能取到  \(String(describing: valueglobal))");
    let valuemain = DispatchQueue.main.getSpecific(key: key);
    print("从main queue中取queue key 为  main \(String(describing: valuemain))");
    let value = DispatchQueue.getSpecific(key: key)
    print("\(String(describing: value))");
    debugPrint("main queue: \(value != nil)")
    let globalValue = DispatchQueue.getSpecific(key: globalKey);
    debugPrint("global queue: \(globalValue != nil)")
}
DispatchQueue.global().async(execute: log)//切换成异步
RunLoop.current.run()

result

Hello, World!
"current thread out: <NSThread: 0x100f0dd20>{number = 1, name = main}"
"main thread: false"
"current thread in: <NSThread: 0x100f92dd0>{number = 2, name = (null)}"
从globalqueue中取queue key 为  main 是否能取到  nil
从main queue中取queue key 为  main Optional("main")
nil
"main queue: false"
"global queue: true

DispatchQueue.main & DispatchQueue.global() 是通过类属性取到的，这两个queue系统早就帮我们分配好了

使用DispatchQueue.getSpecific方法去取队列的value的时候，是看你有没有把这个队列分发出去，上面的例子中分发的是DispatchQueue.global()，所以你去取key为main 的队列的value时候取不到

上个例子中把最有一个RunLoop.current.run()屏蔽

result

Hello, World!
"current thread out: <NSThread: 0x10180b7f0>{number = 1, name = main}"
Program ended with exit code: 0

线程都来不及切换进程就已经退出了

再看例子2 使用dispatchMain()

import Foundation
print("Hello, World!")
debugPrint("current thread out: \(Thread.current)") //主线程在这里呢 看我的number编号
let key = DispatchSpecificKey<String>()
let queueGlobal =  DispatchQueue.global();
let globalKey = DispatchSpecificKey<String>();
DispatchQueue.main.setSpecific(key: key, value: "main")
DispatchQueue.global().setSpecific(key: globalKey, value: "global");
func log() {
    debugPrint("main thread: \(Thread.isMainThread)")
    debugPrint("current thread in: \(Thread.current)")
    let valueglobal = DispatchQueue.global().getSpecific(key: key);
    print("从globalqueue中取queue key 为  main 是否能取到  \(String(describing: valueglobal))");
    let valuemain = DispatchQueue.main.getSpecific(key: key);
    print("从main queue中取queue key 为  main \(String(describing: valuemain))");
    let value = DispatchQueue.getSpecific(key: key)
    print("\(String(describing: value))");
    debugPrint("main queue: \(value != nil)")
    let globalValue = DispatchQueue.getSpecific(key: globalKey);
    debugPrint("global queue: \(globalValue != nil)")
}
DispatchQueue.global().async(execute: log)
dispatchMain();

result: DispatchQueue.global()的global方法被执行了，dispatchMain() 只有无法停止这个进程，只能强制退出，dispatchMain() 没有返回值,使得进程永远存在

Hello, World!
"current thread out: <NSThread: 0x102104100>{number = 1, name = main}"
"main thread: false"
"current thread in: <NSThread: 0x1022134f0>{number = 2, name = (null)}"
从globalqueue中取queue key 为  main 是否能取到  nil
从main queue中取queue key 为  main Optional("main")
nil
"main queue: false"
"global queue: true"

dispatchMain() 官方解释是 Executes blocks submitted to the main queue. 字面翻译就是 "把main queue 的代码块都执行了"
思考：dispatchMain() 为什么把 DispatchQueue.global() 也执行了呢？
巴哥的猜想是 DispatchQueue.global().async async的代码块一定是在主队列中

总结 iOS主线程和主队列的区别

主队列到底是不是在主线程中执行，巴哥的解释是 一定会在主线程执行，关键是你有没有把它分发出去，只要你分发就一定是在主线程中执行。DispatchQueue.main.async 系统默认会把队列派发到主线程中，这篇文章的例子中派发不是main queue 而是 global queue ，这两者是有区别的

小结

进程是拥有资源的最小单位。线程是执行的最小单位。

线程之间是平等的，主线程只不过是 number = 1的线程，应用程序的主线程，也只不过是在number = 1的线程上启动了Runloop，让number = 1的线程常驻，使得进程不会被销毁

主线程是系统帮我们创建的，而子线程是需要依赖主线程来创建

主队列一定是在主线程中执行的

队列之间也平等的，系统默认会帮助我们分配两个队列dispatchMain()和DispatchQueue.global()

线程和队列没有可比性，两者是完全不同的两个概念

最后编辑于：2018.12.06 18:38:42

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

IOS 进程、主线程、主队列（巴哥莫出品）

IOS 进程、主线程、主队列（巴哥莫出品）

目录

前言

内容概述

进程和线程概念复习

main 启动

主线程VS子线程

主线程

主队列

队列和线程

巴哥浅见iOS主线程和主队列的区别

总结 iOS主线程和主队列的区别

小结

推荐阅读更多精彩内容

IOS 进程、主线程、主队列 （巴哥莫出品）

目录

前言

内容概述

进程和线程概念复习

main 启动

主线程VS子线程

主线程

主队列

队列和线程

巴哥浅见iOS主线程和主队列的区别

总结 iOS主线程和主队列的区别

小结

推荐阅读更多精彩内容

IOS 进程、主线程、主队列（巴哥莫出品）