Python 中多线程与多处理之间的区别

一、说明

?? 在本文中，我们将学习 Python 中多线程和多处理的内容、原因和方式。在我们深入研究代码之前，让我们了解这些术语的含义。

二、基本术语和概念

?? 程序是一个可执行文件，它由一组执行某些任务的指令组成，通常存储在计算机的磁盘上。
?? 进程就是我们所说的程序，它已与运行所需的所有资源一起加载到内存中。它有自己的内存空间。
?? 线程是进程中的执行单元。一个进程可以有多个线程作为其一部分运行，其中每个线程使用进程的内存空间并与其他线程共享。
?? 多线程是一种技术，其中进程生成多个线程以执行不同的任务，大约在同一时间，一个接一个。这给你一种错觉，即线程是并行运行的，但实际上它们是以并发方式运行的。在 Python 中，全局解释器锁（GIL）阻止线程同时运行。
多处理是一种实现最真实形式的并行性的技术。多个进程跨多个 CPU 内核运行，这些内核之间不共享资源。每个进程可以在自己的内存空间中运行许多线程。在 Python 中，每个进程都有自己的 Python 解释器实例，负责执行指令。
?? 现在，让我们进入程序，我们尝试以六种不同的方式执行两种不同类型的函数：IO 绑定和 CPU 绑定。在 IO 绑定函数中，我们要求 CPU 闲置并打发时间，而在 CPU 绑定函数中，CPU 将忙于产生一些数字。

要求：

一台 Windows 计算机（我的机器有 6 个内核）。

已安装 Python 3.x。

任何用于编写 Python 程序的文本编辑器/IDE（我在这里使用 Sublime Text）。

?? 注意：以下是我们程序的结构，它将在所有六个部分中通用。在提到它的地方 # YOUR CODE SNIPPET HERE，将其替换为每个部分的代码片段。

import time, os
from threading import Thread, current_thread
from multiprocessing import Process, current_process


COUNT = 200000000
SLEEP = 10

def io_bound(sec):

	pid = os.getpid()
	threadName = current_thread().name
	processName = current_process().name

	print(f"{pid} * {processName} * {threadName} 
		---> Start sleeping...")
	time.sleep(sec)
	print(f"{pid} * {processName} * {threadName} 
		---> Finished sleeping...")

def cpu_bound(n):

	pid = os.getpid()
	threadName = current_thread().name
	processName = current_process().name

	print(f"{pid} * {processName} * {threadName} 
		---> Start counting...")

	while n>0:
		n -= 1

	print(f"{pid} * {processName} * {threadName} 
		---> Finished counting...")

if __name__=="__main__":
	start = time.time()

	# YOUR CODE SNIPPET HERE

	end = time.time()
	print('Time taken in seconds -', end - start)

三、进程对CPU绑定

第 1 部分：一个接一个地运行 IO 绑定任务两次…

# Code snippet for Part 1
io_bound(SLEEP)
io_bound(SLEEP)

?? 在这里，我们要求 CPU 执行函数 io_bound（），该函数将整数（此处为 10）作为参数，并要求 CPU 休眠几秒钟。此执行总共需要 20 秒，因为每个函数执行需要 10 秒才能完成。请注意，它是同一个 MainProcess 使用其默认线程 MainThread 一个接一个地调用我们的函数两次。
在这里插入图片描述

第 2 部分：使用线程运行受 IO 绑定的任务…

# Code snippet for Part 2
t1 = Thread(target = io_bound, args =(SLEEP, ))
t2 = Thread(target = io_bound, args =(SLEEP, ))
t1.start()
t2.start()
t1.join()
t2.join()

?? 在这里，让我们使用 Python 中的线程来加快函数的执行速度。线程 Thread-1 和 Thread-2 由我们的 MainProcess 启动，每个线程几乎同时调用我们的函数。两个线程同时完成休眠 10 秒的工作。这大大缩短了整个程序的总执行时间，减少了 50%。因此，多线程是执行任务的首选解决方案，其中 CPU 的空闲时间可用于执行其他任务。因此，通过利用等待时间来节省时间。
在这里插入图片描述

第 3 部分：一个接一个地运行两次 CPU 密集型任务…

# Code snippet for Part 3
cpu_bound(COUNT)
cpu_bound(COUNT)

?? 在这里，我们将调用我们的函数 cpu_bound（），它将一个大数字（此处为 200000000）作为参数，并在每一步将其递减，直到它为零。我们的 CPU 被要求在每次函数调用时进行倒计时，这大约需要 12 秒（这个数字可能因您的计算机而异）。因此，整个程序的执行花了我大约 26 秒才能完成。请注意，MainProcess 再次在其默认线程 MainThread 中一个接一个地调用该函数两次。

在这里插入图片描述

第 4 部分：线程可以加快我们受 CPU 限制的任务吗？

# Code snippet for Part 4
t1 = Thread(target = cpu_bound, args =(COUNT, ))
t2 = Thread(target = cpu_bound, args =(COUNT, ))
t1.start()
t2.start()
t1.join()
t2.join()

?? 好的，我们刚刚证明了线程对于多个 IO 绑定任务的效果非常好。让我们使用相同的方法来执行 CPU 密集型任务。好吧，它最初确实同时启动了我们的线程，但最终，我们看到整个程序执行花费了大约 40 秒！刚刚发生了什么？这是因为当 Thread-1 启动时，它获得了全局解释器锁（GIL），从而阻止 Thread-2 使用 CPU。因此，Thread-2 必须等待 Thread-1 完成其任务并释放锁，以便它可以获取锁并执行其任务。这种锁的获取和释放增加了总执行时间的开销。因此，我们可以肯定地说，对于需要 CPU 处理某事的任务来说，线程并不是一个理想的解决方案。
在这里插入图片描述

第 5 部分：那么，将任务拆分为单独的流程是否有效？

# Code snippet for Part 5
p1 = Process(target = cpu_bound, args =(COUNT, ))
p2 = Process(target = cpu_bound, args =(COUNT, ))
p1.start()
p2.start()
p1.join()
p2.join()

?? 让我们切入正题。多处理就是答案。在这里，MainProcess 启动了两个子进程，它们具有不同的 PID，每个子进程都负责将数字减少到零。每个进程并行运行，使用单独的 CPU 内核和它自己的 Python 解释器实例，因此整个程序执行只需 12 秒。请注意，输出可能以无序方式打印，因为进程彼此独立。每个进程都在其自己的默认线程 MainThread 中执行函数。在程序执行期间打开任务管理器。您可以看到 Python 解释器的 3 个实例，MainProcess、Process-1 和 Process-2 各一个。您还可以看到，在程序执行期间，两个子进程的功耗为“非常高”，因为它们正在执行的任务实际上正在对它们自己的 CPU 内核造成影响，如 CPU 性能图中的峰值所示。

在这里插入图片描述

第 6 部分：我们对 IO 绑定任务使用多处理…

# Code snippet for Part 6
p1 = Process(target = io_bound, args =(SLEEP, ))
p2 = Process(target = io_bound, args =(SLEEP, ))
p1.start()
p2.start()
p1.join()
p2.join()

?? 现在我们已经对多处理帮助我们实现并行性有了大致的了解，我们将尝试使用这种技术来运行我们的 IO 绑定任务。我们确实观察到结果是非凡的，就像在多线程的情况下一样。由于进程 1 和进程 2 正在执行要求自己的 CPU 内核闲置几秒钟的任务，因此我们没有发现高功耗。但是，进程的创建本身就是一项 CPU 繁重的任务，并且比创建线程需要更多的时间。此外，进程需要的资源比线程多。因此，最好将多处理作为 IO 绑定任务的第二个选项，多线程是第一个选项。
在这里插入图片描述
?? 嗯，那是一段相当长的旅程。我们看到了执行一项任务的六种不同方法，大约需要 10 秒，具体取决于任务对 CPU 的影响是轻还是重。

四、结论

?? 底线：IO 绑定任务的多线程处理。CPU密集型任务的多处理。

Python 中的多线程	Python 中的多处理
它实现了并发性。	它实现了并行性。
在并行计算的情况下，Python 不支持多线程。	Python 在并行计算的情况下支持多处理。
在多线程中，单个进程同时生成多个线程。	在多处理中，多个线程同时跨多个内核运行。
无法对多线程进行分类。	多处理可以分为对称或非对称。

。