Other answers have focused more on the multithreading vs multiprocessing aspect, but in python Global Interpreter Lock (GIL) has to be taken into account. When more number (say k) of threads are created, generally they will not increase the performance by k times, as it will still be running as a single threaded application. GIL is a global lock which locks everything out and allows only single thread execution utilizing only a single core. The performance does increase in places where C extensions like numpy, Network, I/O are being used, where a lot of background work is done and GIL is released. So when threading is used, there is only a single operating system level thread while python creates pseudo-threads which are completely managed by threading itself but are essentially running as a single process. Preemption takes place between these pseudo threads. If the CPU runs at maximum capacity, you may want to switch to multiprocessing. Now in case of self-contained instances of execution, you can instead opt for pool. But in case of overlapping data, where you may want processes communicating you should use multiprocessing.Process.

进程可能有多个线程。这些线程可以共享内存，并且是进程中的执行单元。

进程运行在CPU上，因此线程驻留在每个进程之下。进程是独立运行的独立实体。如果您想在每个进程之间共享数据或状态，您可以使用内存存储工具，如缓存(redis, memcache)，文件或数据库。

Other answers have focused more on the multithreading vs multiprocessing aspect, but in python Global Interpreter Lock (GIL) has to be taken into account. When more number (say k) of threads are created, generally they will not increase the performance by k times, as it will still be running as a single threaded application. GIL is a global lock which locks everything out and allows only single thread execution utilizing only a single core. The performance does increase in places where C extensions like numpy, Network, I/O are being used, where a lot of background work is done and GIL is released. So when threading is used, there is only a single operating system level thread while python creates pseudo-threads which are completely managed by threading itself but are essentially running as a single process. Preemption takes place between these pseudo threads. If the CPU runs at maximum capacity, you may want to switch to multiprocessing. Now in case of self-contained instances of execution, you can instead opt for pool. But in case of overlapping data, where you may want processes communicating you should use multiprocessing.Process.

线程共享相同的内存空间，以确保两个线程不共享相同的内存位置，因此必须采取特殊的预防措施。CPython解释器使用一种称为GIL的机制来处理这个问题，或全局解释器锁

什么是GIL(我只是想澄清GIL，上面重复了一次)?

在CPython中，全局解释器锁(GIL)是一个互斥锁，用于保护对Python对象的访问，防止多个线程同时执行Python字节码。这个锁是必要的，主要是因为CPython的内存管理不是线程安全的。

对于主要问题，我们可以使用用例，如何进行比较?

1-线程的用例:在GUI程序中，线程可以用来使应用程序具有响应性。例如，在文本编辑程序中，一个线程可以负责记录用户输入，另一个线程可以负责显示文本，第三个线程可以进行拼写检查，等等。在这里，程序必须等待用户交互。这是最大的瓶颈。线程的另一个用例是受IO限制或受网络限制的程序，例如web scraper。

2- Multiprocessing的用例:当程序是CPU密集型的，并且不需要做任何IO或用户交互的情况下，Multiprocessing优于线程。

要了解更多详细信息，请访问此链接和链接，或者您需要深入了解线程访问这里，多处理访问这里

以下是我想到的一些优点和缺点。

多处理

Pros

独立的内存空间 代码通常很简单 利用多个cpu和核 避免了cPython的GIL限制 消除了对同步原语的大部分需求，除非您使用共享内存(相反，它更像是IPC的通信模型) 子进程是可中断/可杀死的 Python多处理模块包含有用的抽象，其接口类似于线程。线程 必须使用cPython进行cpu绑定处理

Cons

IPC有点复杂，开销更大(通信模型vs.共享内存/对象) 更大的内存占用

线程

Pros

轻量级——低内存占用 共享内存-使访问状态从另一个上下文更容易 允许您轻松地创建响应式ui 正确释放GIL的cPython C扩展模块将并行运行 对于I/ o约束应用程序来说是一个很好的选择

Cons

cPython -服从GIL 不是可中断/ killable 如果不遵循命令队列/消息泵模型(使用queue模块)，则必须手动使用同步原语(需要对锁定的粒度进行决策) 代码通常更难理解和正确编写——竞争条件的可能性急剧增加

多处理

Multiprocessing通过增加cpu来提高计算能力。 多个进程同时执行。 创建流程既耗时又耗费资源。 多处理可以是对称的也可以是非对称的。

Python中的多处理库使用独立的内存空间，多个CPU核心，绕过CPython中的GIL限制，子进程是可杀死的(例如程序中的函数调用)，并且更容易使用。 该模块的一些注意事项是内存占用较大，IPC稍微复杂一些，开销更大。

多线程

多线程创建单个进程的多个线程，以提高计算能力。 一个进程的多个线程并发执行。 线程的创建在时间和资源上都是经济的。

多线程库是轻量级的，共享内存，负责响应式UI，并用于I/O绑定应用程序。 该模块不可杀死，并受GIL约束。 多个线程生活在同一个进程中的同一个空间中，每个线程将执行特定的任务，有自己的代码，自己的堆栈内存，指令指针，并共享堆内存。 如果一个线程有内存泄漏，它会损害其他线程和父进程。

使用Python的多线程和多处理示例

Python 3有启动并行任务的功能。这使我们的工作更容易。

它有线程池和进程池。

下面让我们来了解一下:

ThreadPoolExecutor例子

import concurrent.futures
import urllib.request

URLS = ['http://www.foxnews.com/',
        'http://www.cnn.com/',
        'http://europe.wsj.com/',
        'http://www.bbc.co.uk/',
        'http://some-made-up-domain.com/']

# Retrieve a single page and report the URL and contents
def load_url(url, timeout):
    with urllib.request.urlopen(url, timeout=timeout) as conn:
        return conn.read()

# We can use a with statement to ensure threads are cleaned up promptly
with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
    # Start the load operations and mark each future with its URL
    future_to_url = {executor.submit(load_url, url, 60): url for url in URLS}
    for future in concurrent.futures.as_completed(future_to_url):
        url = future_to_url[future]
        try:
            data = future.result()
        except Exception as exc:
            print('%r generated an exception: %s' % (url, exc))
        else:
            print('%r page is %d bytes' % (url, len(data)))

ProcessPoolExecutor

import concurrent.futures
import math

PRIMES = [
    112272535095293,
    112582705942171,
    112272535095293,
    115280095190773,
    115797848077099,
    1099726899285419]

def is_prime(n):
    if n % 2 == 0:
        return False

    sqrt_n = int(math.floor(math.sqrt(n)))
    for i in range(3, sqrt_n + 1, 2):
        if n % i == 0:
            return False
    return True

def main():
    with concurrent.futures.ProcessPoolExecutor() as executor:
        for number, prime in zip(PRIMES, executor.map(is_prime, PRIMES)):
            print('%d is prime: %s' % (number, prime))

if __name__ == '__main__':
    main()