我正在学习如何使用Python中的 threading 和 multiprocessing 模块并行运行代码以提高效率。
我发现很难理解 threading.Thread() 对象和 multiprocessing.Process() 对象之间的区别，可能是因为我没有相应的理论背景知识。
同时，我也不太清楚如何实例化一个作业队列，只有其中的 4 个作业在并行运行，而其余作业等待资源释放后再执行。
我觉得文档中的示例很清晰，但不够详尽；一旦涉及到稍微复杂一点的问题，我就会接收到很多奇怪的错误（比如无法pickle某个方法等）。
那么，我应该在什么情况下使用 threading 模块或 multiprocessing 模块呢？
你能为我提供一些资源链接，以便了解这两个模块背后的概念和如何正确地使用它们来完成复杂的任务吗？
Giulio Franco所说的是关于多线程和多进程通常情况下的真相。
然而，Python*存在一个额外的问题：全局解释器锁定，防止同一进程中的两个线程同时运行Python代码。这意味着如果您有8个核心，并将代码更改为使用8个线程，则它将无法使用800％的CPU并以8倍的速度运行；它将使用相同的100％的CPU并以相同的速度运行。(实际上，它会运行得稍微慢一些，因为即使没有任何共享数据，线程也会增加额外的开销，但现在先忽略这一点。)
这里有例外情况。如果您的代码的重计算实际上不是在Python中进行的，而是在某个具有自定义C代码（如numpy应用程序）的库中进行适当的GIL处理，则可以从线程获得预期的性能优势。如果重计算由一些子进程完成并等待，则也是如此。
更重要的是，有些情况下这并不重要。例如，网络服务器大部分时间都在从网络中读取数据包，GUI应用程序大部分时间都在等待用户事件。在网络服务器或GUI应用程序中使用线程的一个原因是允许您执行长时间运行的“后台任务”，而不会停止主线程继续服务网络数据包或GUI事件。Python线程完全可以胜任此任务。(从技术上讲，这意味着Python线程提供了并发性，尽管它们没有提供核心并行性。)
但是，如果您在纯Python中编写CPU密集型程序，则使用更多线程通常是没有帮助的。
使用单独的进程没有GIL的问题，因为每个进程都有自己独立的GIL。当然，您仍然需要权衡线程和进程之间的所有相同的折衷，就像在任何其他语言中一样——在进程之间共享数据比在线程之间共享数据更加困难和昂贵，运行大量进程或经常创建和销毁它们可能成本很高等等。但是，GIL对于进程的平衡影响很大，在C或Java中不是这样的。因此，在Python中您将更频繁地使用多进程。
concurrent.futures库将代码编写成像这样的线程池。with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
executor.submit(job, argument)
executor.map(some_function, collection_of_independent_things)
# ...
Future对象部分。with concurrent.futures.ProcessPoolExecutor(max_workers=4) as executor:
但是如果你的任务无法自包含呢？如果你能够通过设计代码，让它以传递消息的方式从一个任务传递到另一个任务，那就还是相当容易的。你可能需要使用 threading.Thread 或 multiprocessing.Process 代替依赖池。而且你将需要显式地创建 queue.Queue 或 multiprocessing.Queue 对象。(还有很多其他的选项——管道，套接字，带有锁的文件等等，但关键是，如果执行器的自动魔法不足，你必须手动做一些事情。)
但是如果你甚至不能依赖于消息传递呢？如果你需要两个任务都改变同一个结构，并看到彼此的改变，那么你将需要进行手动同步(锁，信号量，条件等)，并且如果你想使用进程，还需要显式共享内存对象。这时多线程(或多进程)就会变得困难起来。如果可以避免，那太好了；如果不能，你将需要阅读更多的内容，超过 SO 答案所能提供的范围。
根据一条评论，您想了解Python中的线程(thread)和进程(process)之间的区别。如果您阅读Giulio Franco的答案以及我的回答和我们所有的链接，那么应该涵盖了所有内容...但是总结肯定会有帮助，因此我们来看看：
ctypes类型这样的底层格式中。threading模块没有multiprocessing模块的某些功能。（您可以使用multiprocessing.dummy在线程之上获取大部分缺失的API，或者使用像concurrent.futures这样的高级模块而不必担心它。）* 实际上有这个问题的不是Python语言本身，而是CPython，即该语言的“标准”实现方式。像Jython这样的一些其他实现方式没有全局解释器锁（GIL）。
** 如果您在多进程中使用fork启动方法 - 在大多数非Windows平台上都可以这样做 - 每个子进程获取父进程在启动子进程时拥有的所有资源，这也是向子进程传递数据的另一种方法。
pickle文档中有解释），然后最坏的情况下，您的愚蠢包装器是 def wrapper(obj, *args): return obj.wrapper(*args)。 - abarnert一个进程内可以存在多个线程。 属于同一进程的线程共享同一块内存区域（可以读写相同的变量，并且彼此干扰）。 相反，不同的进程存在于不同的内存区域，并且每个进程都有自己的变量。为了通信，进程必须使用其他通道（文件、管道或套接字）。
如果您想并行计算，您可能需要使用多线程，因为您可能希望线程在同一块内存上进行协作。
就性能而言，线程比进程更快地创建和管理（因为操作系统不需要分配一个全新的虚拟内存区域），并且线程间通信通常比进程间通信更快速。但是编程线程会更加困难。线程可能会相互干扰并且可以写入彼此的内存，但这种情况发生的方式并不总是明显的（因为多种因素，主要是指令重排序和内存缓存），因此您需要同步原语来控制对变量的访问。
threading和multiprocessing有何区别。 - Antti Haapala -- Слава УкраїніPython文档引用
我已经突出了关于进程与线程以及GIL的关键Python文档引用: 什么是CPython中的全局解释器锁（GIL）？
进程 vs 线程实验
我进行了一些基准测试，以更具体地展示差异。
在基准测试中，我计时了在8个超线程CPU上使用各种线程数量的CPU和IO绑定工作。每个线程提供的工作总是相同的，因此更多的线程意味着更多的总工作量。
结果如下:
画数据。
结论：
对于CPU密集型工作，多进程始终更快，可能是由于GIL的原因。
对于IO密集型工作，两者速度完全相同。
线程仅扩展到约4倍，而不是预期的8倍，因为我在一台8超线程机器上。
与C POSIX CPU密集型工作相比，后者达到了预期的8倍加速： time（1）的输出中'real'，'user'和'sys'是什么意思？
待办事项：我不知道原因，必须有其他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 upstream + plotting code on same directory。
在Ubuntu 18.10、Python 3.6.7上测试通过，在联想ThinkPad P51笔记本电脑上使用，配备CPU：Intel Core i7-7820HQ CPU（4个核心/8个线程），RAM：2x Samsung M471A2K43BB1-CRC（2x 16GiB），SSD：Samsung MZVLB512HAJQ-000L7（3,000 MB/s）。
可视化给定时间正在运行的线程
这篇文章https://rohanvarma.me/GIL/告诉我，你可以在threading.Thread的target=参数和multiprocessing.Process中运行回调函数，以便在每个线程被调度时运行该回调函数。
这允许我们精确地查看每个时间运行的线程。当这样做时，我们会看到类似于以下内容（我制作了这个特定的图表）：
+--------------------------------------+
+ Active threads / processes +
+-----------+--------------------------------------+
|Thread 1 |******** ************ |
| 2 | ***** *************|
+-----------+--------------------------------------+
|Process 1 |*** ************** ****** **** |
| 2 |** **** ****** ** ********* **********|
+-----------+--------------------------------------+
+ Time --> +
+--------------------------------------+
这将表明：
>>> do_work(50, 300, 'thread','fileio')
do_work function took 455.752 ms
>>> do_work(50, 300, 'process','fileio')
do_work function took 319.279 ms
>>> do_work(50, 2000, 'thread','square')
do_work function took 338.309 ms
>>> do_work(50, 2000, 'process','square')
do_work function took 287.488 ms
from multiprocessing import Pool
from multiprocessing.pool import ThreadPool
import time
import sys
import os
from glob import glob
text_for_test = str(range(1,100000))
def fileio(i):
try :
os.remove(glob('./test/test-*'))
except :
pass
f=open('./test/test-'+str(i),'a')
f.write(text_for_test)
f.close()
f=open('./test/test-'+str(i),'r')
text = f.read()
f.close()
def square(i):
return i*i
def timing(f):
def wrap(*args):
time1 = time.time()
ret = f(*args)
time2 = time.time()
print '%s function took %0.3f ms' % (f.func_name, (time2-time1)*1000.0)
return ret
return wrap
result = None
@timing
def do_work(process_count, items, process_type, method) :
pool = None
if process_type == 'process' :
pool = Pool(processes=process_count)
else :
pool = ThreadPool(processes=process_count)
if method == 'square' :
multiple_results = [pool.apply_async(square,(a,)) for a in range(1,items)]
result = [res.get() for res in multiple_results]
else :
multiple_results = [pool.apply_async(fileio,(a,)) for a in range(1,items)]
result = [res.get() for res in multiple_results]
do_work(50, 300, 'thread','fileio')
do_work(50, 300, 'process','fileio')
do_work(50, 2000, 'thread','square')
do_work(50, 2000, 'process','square')
>>> do_work(50, 300, 'thread', 'fileio') --> 237.557 毫秒
>>> do_work(50, 300, 'process', 'fileio') --> 323.963 毫秒
>>> do_work(50, 2000, 'thread', 'square') --> 232.082 毫秒
>>> do_work(50, 2000, 'process', 'square') --> 282.785 毫秒 - Alan Garrido区别
| 线程 | 进程 |
|---|---|
| 使用本机线程，而非本机进程。 线程属于进程。 共享内存，非进程间通信。 受全局解释器锁限制，非真正的并行执行。 适用于I/O绑定任务，非CPU绑定任务。 |
使用本机进程，而非本机线程。 进程具有线程和子进程。 重量级且启动较慢，非轻量级且启动较快。 进程间通信，而非共享内存。 适用于CPU绑定任务，可能不适用于I/O绑定任务。 |
使用方法
好的，Giulio Franco已经回答了大部分问题。我将进一步阐述消费者-生产者问题，我认为这将为您使用多线程应用程序的解决方案指明正确的方向。
fill_count = Semaphore(0) # items produced
empty_count = Semaphore(BUFFER_SIZE) # remaining space
buffer = Buffer()
def producer(fill_count, empty_count, buffer):
while True:
item = produceItem()
empty_count.down();
buffer.push(item)
fill_count.up()
def consumer(fill_count, empty_count, buffer):
while True:
fill_count.down()
item = buffer.pop()
empty_count.up()
consume_item(item)
您可以从以下链接了解更多关于同步原语的内容：
http://linux.die.net/man/7/sem_overview
http://docs.python.org/2/library/threading.html
伪代码如上所示。我想你应该搜索生产者消费者问题以获取更多参考资料。
Thread模块（在Python 3.x中称为_thread）。老实说，我自己从来没有理解过它们之间的区别... - DunnoThread/_thread文档明确指出的那样，它是“低级原语”。您可以使用它来构建自定义同步对象，控制线程树的加入顺序等。如果您无法想象为什么需要使用它，请不要使用它，而应坚持使用threading。 - abarnert