我试图理解多处理相对于线程的优势。我知道多处理绕过了全局解释器锁，但是还有什么其他的优势，线程不能做同样的事情吗?
当前回答
Python文档引用
这个答案的规范版本现在是双重问题:线程模块和多处理模块之间有什么区别?
我已经突出显示了Python文档中关于进程vs线程和GIL的关键引用:什么是CPython中的全局解释器锁(GIL) ?
进程与线程实验
为了更具体地展示差异，我做了一些基准测试。
在基准测试中，我对8超线程CPU上不同数量的线程进行了CPU和IO限制。每个线程提供的功总是相同的，因此线程越多，提供的总功就越多。
结果如下:
图数据。
结论:
对于CPU约束的工作，多处理总是更快，可能是由于GIL IO绑定工作。两者的速度完全相同 线程只能扩展到大约4倍，而不是预期的8倍，因为我使用的是8超线程机器。 与此相比，C POSIX cpu绑定的工作达到了预期的8倍加速:'real'， 'user'和'sys'在time(1)的输出中是什么意思? 我不知道这是什么原因，肯定有其他Python的低效率因素在起作用。
测试代码:
#!/usr/bin/env python3
import multiprocessing
import threading
import time
import sys
def cpu_func(result, niters):
'''
A useless CPU bound function.
'''
for i in range(niters):
result = (result * result * i + 2 * result * i * i + 3) % 10000000
return result
class CpuThread(threading.Thread):
def __init__(self, niters):
super().__init__()
self.niters = niters
self.result = 1
def run(self):
self.result = cpu_func(self.result, self.niters)
class CpuProcess(multiprocessing.Process):
def __init__(self, niters):
super().__init__()
self.niters = niters
self.result = 1
def run(self):
self.result = cpu_func(self.result, self.niters)
class IoThread(threading.Thread):
def __init__(self, sleep):
super().__init__()
self.sleep = sleep
self.result = self.sleep
def run(self):
time.sleep(self.sleep)
class IoProcess(multiprocessing.Process):
def __init__(self, sleep):
super().__init__()
self.sleep = sleep
self.result = self.sleep
def run(self):
time.sleep(self.sleep)
if __name__ == '__main__':
cpu_n_iters = int(sys.argv[1])
sleep = 1
cpu_count = multiprocessing.cpu_count()
input_params = [
(CpuThread, cpu_n_iters),
(CpuProcess, cpu_n_iters),
(IoThread, sleep),
(IoProcess, sleep),
]
header = ['nthreads']
for thread_class, _ in input_params:
header.append(thread_class.__name__)
print(' '.join(header))
for nthreads in range(1, 2 * cpu_count):
results = [nthreads]
for thread_class, work_size in input_params:
start_time = time.time()
threads = []
for i in range(nthreads):
thread = thread_class(work_size)
threads.append(thread)
thread.start()
for i, thread in enumerate(threads):
thread.join()
results.append(time.time() - start_time)
print(' '.join('{:.6e}'.format(result) for result in results))
相同目录上的GitHub上游+绘图代码。
在Ubuntu 18.10, Python 3.6.7，联想ThinkPad P51笔记本电脑上测试，CPU:英特尔酷睿i7-7820HQ CPU(4核/ 8线程)，RAM: 2倍三星M471A2K43BB1-CRC(2倍16GiB)， SSD:三星MZVLB512HAJQ-000L7 (3000 MB/s)。
可视化给定时间哪些线程正在运行
这篇文章https://rohanvarma.me/GIL/告诉我，你可以运行一个回调每当线程调度与目标=参数的线程。线程和multiprocessing.Process。
这允许我们准确地查看每次运行的线程。当这完成后，我们会看到(我制作了这张特殊的图表):
+--------------------------------------+
+ Active threads / processes +
+-----------+--------------------------------------+
|Thread 1 |******** ************ |
| 2 | ***** *************|
+-----------+--------------------------------------+
|Process 1 |*** ************** ****** **** |
| 2 |** **** ****** ** ********* **********|
+-----------+--------------------------------------+
+ Time --> +
+--------------------------------------+
这将表明:
线程由GIL完全序列化 进程可以并行运行
其他回答
线程共享相同的内存空间，以确保两个线程不共享相同的内存位置，因此必须采取特殊的预防措施。CPython解释器使用一种称为GIL的机制来处理这个问题，或全局解释器锁
什么是GIL(我只是想澄清GIL，上面重复了一次)?
在CPython中，全局解释器锁(GIL)是一个互斥锁，用于保护对Python对象的访问，防止多个线程同时执行Python字节码。这个锁是必要的，主要是因为CPython的内存管理不是线程安全的。
对于主要问题，我们可以使用用例，如何进行比较?
1-线程的用例:在GUI程序中，线程可以用来使应用程序具有响应性。例如，在文本编辑程序中，一个线程可以负责记录用户输入，另一个线程可以负责显示文本，第三个线程可以进行拼写检查，等等。在这里，程序必须等待用户交互。这是最大的瓶颈。线程的另一个用例是受IO限制或受网络限制的程序，例如web scraper。
2- Multiprocessing的用例:当程序是CPU密集型的，并且不需要做任何IO或用户交互的情况下，Multiprocessing优于线程。
要了解更多详细信息，请访问此链接和链接，或者您需要深入了解线程访问这里，多处理访问这里
As I learnd in university most of the answers above are right. In PRACTISE on different platforms (always using python) spawning multiple threads ends up like spawning one process. The difference is the multiple cores share the load instead of only 1 core processing everything at 100%. So if you spawn for example 10 threads on a 4 core pc, you will end up getting only the 25% of the cpus power!! And if u spawn 10 processes u will end up with the cpu processing at 100% (if u dont have other limitations). Im not a expert in all the new technologies. Im answering with own real experience background
以下是我想到的一些优点和缺点。
多处理
Pros
独立的内存空间 代码通常很简单 利用多个cpu和核 避免了cPython的GIL限制 消除了对同步原语的大部分需求，除非您使用共享内存(相反，它更像是IPC的通信模型) 子进程是可中断/可杀死的 Python多处理模块包含有用的抽象，其接口类似于线程。线程 必须使用cPython进行cpu绑定处理
Cons
IPC有点复杂，开销更大(通信模型vs.共享内存/对象) 更大的内存占用
线程
Pros
轻量级——低内存占用 共享内存-使访问状态从另一个上下文更容易 允许您轻松地创建响应式ui 正确释放GIL的cPython C扩展模块将并行运行 对于I/ o约束应用程序来说是一个很好的选择
Cons
cPython -服从GIL 不是可中断/ killable 如果不遵循命令队列/消息泵模型(使用queue模块)，则必须手动使用同步原语(需要对锁定的粒度进行决策) 代码通常更难理解和正确编写——竞争条件的可能性急剧增加
进程可能有多个线程。这些线程可以共享内存，并且是进程中的执行单元。
进程运行在CPU上，因此线程驻留在每个进程之下。进程是独立运行的独立实体。如果您想在每个进程之间共享数据或状态，您可以使用内存存储工具，如缓存(redis, memcache)，文件或数据库。
Python文档引用
这个答案的规范版本现在是双重问题:线程模块和多处理模块之间有什么区别?
我已经突出显示了Python文档中关于进程vs线程和GIL的关键引用:什么是CPython中的全局解释器锁(GIL) ?
进程与线程实验
为了更具体地展示差异，我做了一些基准测试。
在基准测试中，我对8超线程CPU上不同数量的线程进行了CPU和IO限制。每个线程提供的功总是相同的，因此线程越多，提供的总功就越多。
结果如下:
图数据。
结论:
对于CPU约束的工作，多处理总是更快，可能是由于GIL IO绑定工作。两者的速度完全相同 线程只能扩展到大约4倍，而不是预期的8倍，因为我使用的是8超线程机器。 与此相比，C POSIX cpu绑定的工作达到了预期的8倍加速:'real'， 'user'和'sys'在time(1)的输出中是什么意思? 我不知道这是什么原因，肯定有其他Python的低效率因素在起作用。
测试代码:
#!/usr/bin/env python3
import multiprocessing
import threading
import time
import sys
def cpu_func(result, niters):
'''
A useless CPU bound function.
'''
for i in range(niters):
result = (result * result * i + 2 * result * i * i + 3) % 10000000
return result
class CpuThread(threading.Thread):
def __init__(self, niters):
super().__init__()
self.niters = niters
self.result = 1
def run(self):
self.result = cpu_func(self.result, self.niters)
class CpuProcess(multiprocessing.Process):
def __init__(self, niters):
super().__init__()
self.niters = niters
self.result = 1
def run(self):
self.result = cpu_func(self.result, self.niters)
class IoThread(threading.Thread):
def __init__(self, sleep):
super().__init__()
self.sleep = sleep
self.result = self.sleep
def run(self):
time.sleep(self.sleep)
class IoProcess(multiprocessing.Process):
def __init__(self, sleep):
super().__init__()
self.sleep = sleep
self.result = self.sleep
def run(self):
time.sleep(self.sleep)
if __name__ == '__main__':
cpu_n_iters = int(sys.argv[1])
sleep = 1
cpu_count = multiprocessing.cpu_count()
input_params = [
(CpuThread, cpu_n_iters),
(CpuProcess, cpu_n_iters),
(IoThread, sleep),
(IoProcess, sleep),
]
header = ['nthreads']
for thread_class, _ in input_params:
header.append(thread_class.__name__)
print(' '.join(header))
for nthreads in range(1, 2 * cpu_count):
results = [nthreads]
for thread_class, work_size in input_params:
start_time = time.time()
threads = []
for i in range(nthreads):
thread = thread_class(work_size)
threads.append(thread)
thread.start()
for i, thread in enumerate(threads):
thread.join()
results.append(time.time() - start_time)
print(' '.join('{:.6e}'.format(result) for result in results))
相同目录上的GitHub上游+绘图代码。
在Ubuntu 18.10, Python 3.6.7，联想ThinkPad P51笔记本电脑上测试，CPU:英特尔酷睿i7-7820HQ CPU(4核/ 8线程)，RAM: 2倍三星M471A2K43BB1-CRC(2倍16GiB)， SSD:三星MZVLB512HAJQ-000L7 (3000 MB/s)。
可视化给定时间哪些线程正在运行
这篇文章https://rohanvarma.me/GIL/告诉我，你可以运行一个回调每当线程调度与目标=参数的线程。线程和multiprocessing.Process。
这允许我们准确地查看每次运行的线程。当这完成后，我们会看到(我制作了这张特殊的图表):
+--------------------------------------+
+ Active threads / processes +
+-----------+--------------------------------------+
|Thread 1 |******** ************ |
| 2 | ***** *************|
+-----------+--------------------------------------+
|Process 1 |*** ************** ****** **** |
| 2 |** **** ****** ** ********* **********|
+-----------+--------------------------------------+
+ Time --> +
+--------------------------------------+
这将表明:
线程由GIL完全序列化 进程可以并行运行
推荐文章
- 证书验证失败:无法获得本地颁发者证书
- 当使用pip3安装包时，“Python中的ssl模块不可用”
- 无法切换Python与pyenv
- Python if not == vs if !=
- 如何从scikit-learn决策树中提取决策规则?
- 为什么在Mac OS X v10.9 (Mavericks)的终端中apt-get功能不起作用?
- 将旋转的xtick标签与各自的xtick对齐
- 为什么元组可以包含可变项?
- 如何合并字典的字典?
- 如何创建类属性?
- 不区分大小写的“in”
- 在Python中获取迭代器中的元素个数
- 自动化invokerrequired代码模式
- 解析日期字符串并更改格式
- 使用try和。Python中的if
