多进程与多线程区别

        我们知道，在一台计算机中，我们可以同时打开许多软件，比如同时浏览网页、听音乐、打字等等，看似非常正常。但仔细想想，为什么计算机可以做到这么多软件同时运行呢？这就涉及到计算机中的两个重要概念：多进程和多线程了。

1. 全局解释器锁
        全局解释器锁 （英语：Global Interpreter Lock，缩写 GIL）
是 计算机程序设计语言解释器 用于 同步线程 的一种机制，它使得任何时刻仅有 一个线程 在执行，即便在 多核心处理器 上，使用 GIL 的解释器也只允许同一时间执行一个线程。常见的使用 GIL 的解释器有 CPython 与 Ruby MRI。

        如果，你对上面的不理解，也没有问题。通俗的解释就是：你电脑是 一核或者多核 ，还是你的代码写了了多个线程，但因为 GIL 锁的存在你也就只能运行一个线程，无法同时运行多个线程。接下来，我们来用个图片来解释一下：

 

比如图中，假如你开了两个线程（Py thread1 、Py tread2），

1. 当我们线程一（Py thread1）开始执行时，这个线程会去我们的解释器中申请到一个锁。也就是我们的 GIL 锁；

2. 然后，解释器接收到一个请求的时候呢，它就会到我们的 OS 里面，申请我们的系统线程；

3. 系统统一你的线程执行的时候，就会在你的 CPU 上面执行。（假设你现在是四核CPU）；

4. 而我们的另一个线程二（py thread2）也在同步运行。

5. 而线程二在向这个解释器申请 GIL 的时候线程二会卡在这里（Python 解释器），因为它的 GIL 锁已经被线程一给拿走了（也就是说：他要进去执行，必须拿到这把锁）；

6. 线程二要运行的话，就必须等我们的线程一运行完成之后（也就是把我们的 GIL 释放之后（图片中的第5步）线程二才能拿到这把锁）；

7. 当线程二拿到这把锁之后就和线程一的运行过程一样。

① Create > ② GIL > ③ 申请原生线程(OS) > ④ CPU 执行（如果有其他线程，都会卡在 Python 解释器的外边）

这个锁其实是 Python 之父想一劳永逸解决线程的安全问题（也就是禁止多线程同时运行）

2. 多线程的含义

        说起多线程，就不得不先说什么是线程。然而想要弄明白什么是线程，又不得不先说什么是进程。

进程我们可以理解为是一个可以独立运行的程序单位。

比如：

1. 打开一个浏览器，这就开启了一个浏览器进程；
2. 打开一个文本编辑器，这就开启了一个文本编辑器进程。

但一个进程中是可以同时处理很多事情的。

比如：在浏览器中，我们可以在多个选项卡中打开多个页面。

• 有的页面在播放音乐，
• 有的页面在播放视频，
• 有的网页在播放动画，它们可以同时运行，互不干扰。

为什么能同时做到同时运行这么多的任务呢？

        这里就需要引出线程的概念了，其实这一个个任务，实际上就对应着一个个线程的执行。

而进程呢？

        它就是线程的集合，进程就是由一个或多个线程构成的，线程是操作系统进行运算调度的最小单位，是进程中的一个最小运行单元。

比如：

        上面所说的浏览器进程，其中的播放音乐就是一个线程，播放视频也是一个线程，当然其中还有很多其他的线程在同时运行，这些线程的并发或并行执行最后使得整个浏览器可以同时运行这么多的任务。

        了解了线程的概念，多线程就很容易理解了，多线程就是一个进程中同时执行多个线程，前面所说的浏览器的情景就是典型的多线程执行。

3. 并发和并行

        说到多进程和多线程，这里就需要再讲解两个概念，那就是并发和并行。我们知道，一个程序在计算机中运行，其底层是处理器通过运行一条条的指令来实现的。

3.1 并发

        英文叫作 concurrency。它是指同一时刻只能有一条指令执行，但是多个线程的对应的指令被快速轮换地执行。比如：

        一个处理器，它先执行线程 A 的指令一段时间，再执行线程 B 的指令一段时间，再切回到线程 A 执行一段时间。

        由于处理器执行指令的速度和切换的速度非常非常快，人完全感知不到计算机在这个过程中有多个线程切换上下文执行的操作，这就使得宏观上看起来多个线程在同时运行。但微观上只是这个处理器在连续不断地在多个线程之间切换和执行，每个线程的执行一定会占用这个处理器一个时间片段，同一时刻，其实只有一个线程在执行。

3.2 并行

        英文叫作 parallel。它是指同一时刻，有多条指令在多个处理器上同时执行，并行必须要依赖于多个处理器。不论是从宏观上还是微观上，多个线程都是在同一时刻一起执行的。

        并行只能在多处理器系统中存在，如果我们的计算机处理器只有一个核，那就不可能实现并行。

        而并发在单处理器和多处理器系统中都是可以存在的，因为仅靠一个核，就可以实现并发。

举个例子

        比如系统处理器需要同时运行多个线程。如果系统处理器只有一个核，那它只能通过并发的方式来运行这些线程。如果系统处理器有多个核，当一个核在执行一个线程时，另一个核可以执行另一个线程，这样这两个线程就实现了并行执行，当然其他的线程也可能和另外的线程处在同一个核上执行，它们之间就是并发执行。具体的执行方式，就取决于操作系统的调度了。

4. 多线程适用场景

在一个程序进程中，有一些操作是比较耗时或者需要等待的，比如等待数据库的查询结果的返回，等待网页结果的响应。如果使用单线程，处理器必须要等到这些操作完成之后才能继续往下执行其他操作，而这个线程在等待的过程中，处理器明显是可以来执行其他的操作的。如果使用多线程，处理器就可以在某个线程等待的时候，去执行其他的线程，从而从整体上提高执行效率。

像上述场景，线程在执行过程中很多情况下是需要等待的。

比如

网络爬虫就是一个非常典型的例子，爬虫在向服务器发起请求之后，有一段时间必须要等待服务器的响应返回，这种任务就属于 IO 密集型任务。对于这种任务，如果我们启用多线程，处理器就可以在某个线程等待的过程中去处理其他的任务，从而提高整体的爬取效率。

但并不是所有的任务都是 IO 密集型任务，还有一种任务叫作计算密集型任务，也可以称之为 CPU 密集型任务。顾名思义，就是任务的运行一直需要处理器的参与。此时如果我们开启了多线程，一个处理器从一个计算密集型任务切换到切换到另一个计算密集型任务上去，处理器依然不会停下来，始终会忙于计算，这样并不会节省总体的时间，因为需要处理的任务的计算总量是不变的。如果线程数目过多，反而还会在线程切换的过程中多耗费一些时间，整体效率会变低。

所以，如果任务不全是计算密集型任务，我们可以使用多线程来提高程序整体的执行效率。尤其对于网络爬虫这种 IO 密集型任务来说，使用多线程会大大提高程序整体的爬取效率。

5. Python 实现多线程

在 Python 中，实现多线程的模块叫作 threading，是 Python 自带的模块。下面我们来了解下使用 threading 实现多线程的方法。

在具体实现之前，我们先来测试一下多线程与当线程裸奔的速度对比，为了更加直观，我这里使用把每种线程代码单独写出来并做对比：

单线程裸奔：（这也是一个主线程（main thread））

 注意：因为每台电脑的性能不一样，所运行的结果也相对不同（请按实际情况分析）

 接下来我们写一个多线程

我们先创建个字典 (thread_name_time) 来存储我们每个线程的名称与对应的时间

 

 我们可以看到，速度上的区别不大。多线程并发不如单线程顺序执行快这是得不偿失的造成这种情况的原因就是 GIL这里是计算密集型，所以不适用.

在我们执行加减乘除或者图像处理的时候，都是在从 CPU 上面执行才可以。Python 因为 GIL 存在，同一时期肯定只有一个线程在执行，这样这样就是造成我们开是个线程和一个线程没有太大区别的原因。而我们的网络爬虫大多时候是属于 IO 密集与计算机密集。

BIOS：B：Base、I：Input、O：Output、S：System

 也就是你电脑一开机的时候就会启动。

1. 计算密集型

在上面的时候，我们开启了两个线程，如果这两个线程要同时执行，那同一时期 CPU 上只有一个线程在执行。

那从上图可知，那这两个线程就需要频繁的在上下文切换。

Ps：我们这个绿色表示我们这个线程正在执行，红色代表阻塞。

所以，我们可以明显的观察到，线程的上下文切换也是需要消耗资源的（时间-ms）不断的归还和拿取 GIL 等，切换上下文。明显造成很大的资源浪费。

2. IO 密集型

我们现在假设，有个服务器程序（Socket）也就是我们新开的一个程序（也就是我们网络爬虫的最底层）开始爬取目标网页了，我们那个网页呢，有两个线程同时运行，我们线程二已经请求成功开始运行了，也就是上图的 （Thread 2）绿色一条路过去。

而我们的线程一（Thread 1）- Datagram（这里它开启了一个 UDP），然后等待数据建立（也就是等待哪些 HTML、CSS 等数据返回）也就是说，在 Ready to receive（recvfrom）之间都是准备阶段。这样就是有一段时间一直阻塞，而我们的线程二可以一直无停歇也不用切换上下文就一直在运行。这样的 IO 密集型就有很大的好处。

IO 密集型，这样就把我们等待的时间计算进去了，节省了大部分时间。
这里我们需要注意的是，我们的多线程是运行在 IO 密集型上的，我们得区分清楚。
还有就是，资源等待，比如有时候我们使用浏览器发起了一个 Get 请求，那浏览器图标上面在转圈圈的时候就是我们请求资源等待的时间，（也就是图上面的 Datagram 到 Ready to receive ）数据建立到数据接收（就是转圈圈的时间）。我们完全就不需要执行它，就让它等待就好。这个时候让另一个线程去执行就好

换言之就是：第一个线程，我们爬取那个网页转圈圈的时候让另一个线程继续爬取。这样就避免了资源浪费。（把时间都利用起来）

注意： 请求资源是不需要 CPU 进行计算的，CPU 参与是很少的，而我们第一个例子，计算数字的 for 循环中，是需要 CPU 进行计算的。

5.1 Thread 直接创建子线程
5.1.1 非守护线程
复杂的操作之前需要一个简单的示例开始：

如果有参数的话，我们就对多线程参数进行传参数。代码示例：

 

解析：

我认认真看一下我们的运行结果，

startstopmy first threadTrue2968

我们会发现并不是按我们正常的逻辑执行这一系列的代码。

而是，先执行完 start 然后就直接 stop 然后才会执行我们函数的其他三项。

一个线程它就直接贯穿到底了。也就是先把我们主线程里面的代码运行完，然后才会运行它里面的代码。

我们的代码并不是当代码执行到 thread.start() 等它执行完再执行 print(‘stop’) 。而是，我们线程执行到thread.start() 继续向下执行，同时再执行里面的代码（也就是start()函数里面的代码）。(不会卡在 thread.start() 那里) 也不会随着主线程结束而结束。

因为，程序在执行到 print(‘stop’) 之后就是主线程结束，而里面开的线程是我们自己开的。当我们主线程执行这个 stop 就已经结束了。

这种不会随着主线程结束而销毁的，这种线程它叫做：非守护线程

1. 主线程会跳过创建的线程继续执行；
2. 直到创建线程运行完毕；
3. 程序结束；

既然，有非守护线程。那就还有守护线程。不要急，我再举个非守护线程的例子。

首先，我们可以使用 Thread 类来创建一个线程，创建时需要指定 target 参数为运行的方法名称，如果被调用的方法需要传入额外的参数，则可以通过 Thread的 args参数来指定。示例如下：

 

在这里我们首先声明了一个方法，叫作 target，它接收一个参数为 second，通过方法的实现可以发现，这个方法其实就是执行了一个 time.sleep 休眠操作，second参数就是休眠秒数，其前后都 print了一些内容，其中线程的名字我们通过 threading.current_thread().name 来获取出来，如果是主线程的话，其值就是 MainThread，如果是子线程的话，其值就是 Thread-*。

然后我们通过 Thead类新建了两个线程，target参数就是刚才我们所定义的方法名，args以列表的形式传递。两次循环中，这里 i 分别就是 1 和 5，这样两个线程就分别休眠 1 秒和 5 秒，声明完成之后，我们调用 start 方法即可开始线程的运行。

观察结果我们可以发现，这里一共产生了三个线程，分别是主线程 MainThread和两个子线程 Thread-1、Thread-2。另外我们观察到，主线程首先运行结束，紧接着 Thread-1、Thread-2 才接连运行结束，分别间隔了 1 秒和 4 秒。这说明主线程并没有等待子线程运行完毕才结束运行，而是直接退出了，有点不符合常理。

如果我们想要主线程等待子线程运行完毕之后才退出，可以让每个子线程对象都调用下 join方法，实现如下：

这样，主线程必须等待子线程都运行结束，主线程才继续运行并结束。

5.2 继承 Thread 类创建子线程

另外，我们也可以通过继承 Thr