一文掌握Python多线程与多进程

Python的多线程和多进程

一、简介

并发是今天计算机编程中的一项重要能力，尤其是在面对需要大量计算或I/O操作的任务时。Python 提供了多种并发的处理方式，本篇文章将深入探讨其中的两种：多线程与多进程，解析其使用场景、优点、缺点，并结合代码例子深入解读。
二、多线程

Python中的线程是利用threading模块实现的。线程是在同一个进程中运行的不同任务。
2.1 线程的基本使用

在Python中创建和启动线程很简单。下面是一个简单的例子：

1. import threading
2. import time
4. def print_numbers():
5.     for i in range(10):
6.         time.sleep(1)
7.         print(i)
9. def print_letters():
10.     for letter in 'abcdefghij':
11.         time.sleep(1.5)
12.         print(letter)
14. thread1 = threading.Thread(target=print_numbers)
15. thread2 = threading.Thread(target=print_letters)
17. thread1.start()
18. thread2.start()

复制代码

在这个例子中，print_numbers和print_letters函数都在各自的线程中执行，彼此互不干扰。
2.2 线程同步

由于线程共享内存，因此线程间的数据是可以互相访问的。但是，当多个线程同时修改数据时就会出现问题。为了解决这个问题，我们需要使用线程同步工具，如锁（Lock）和条件（Condition）等。

1. import threading
3. class BankAccount:
4.     def __init__(self):
5.         self.balance = 100  # 共享数据
6.         self.lock = threading.Lock()
8.     def deposit(self, amount):
9.         with self.lock:  # 使用锁进行线程同步
10.             balance = self.balance
11.             balance += amount
12.             self.balance = balance
14.     def withdraw(self, amount):
15.         with self.lock:  # 使用锁进行线程同步
16.             balance = self.balance
17.             balance -= amount
18.             self.balance = balance
20. account = BankAccount()

复制代码

特别说明：Python的线程虽然受到全局解释器锁（GIL）的限制，但是对于IO密集型任务（如网络IO或者磁盘IO），使用多线程可以显著提高程序的执行效率。
三、多进程

Python中的进程是通过multiprocessing模块实现的。进程是操作系统中的一个执行实体，每个进程都有自己的内存空间，彼此互不影响。
3.1 进程的基本使用

在Python中创建和启动进程也是非常简单的：

1. from multiprocessing import Process
2. import os
4. def greet(name):
5.     print(f'Hello {name}, I am process {os.getpid()}')
7. if __name__ == '__main__':
8.     process = Process(target=greet, args=('Bob',))
9.     process.start()
10.     process.join()

复制代码

3.2 进程间的通信

由于进程不共享内存，因此进程间通信（IPC）需要使用特定的机制，如管道（Pipe）、队列（Queue）等。

1. from multiprocessing import Process, Queue
3. def worker(q):
4.     q.put('Hello from
6. process')
8. if __name__ == '__main__':
9.     q = Queue()
10.     process = Process(target=worker, args=(q,))
11.     process.start()
12.     process.join()
14.     print(q.get())  # Prints: Hello from process

复制代码

特别说明：Python的多进程对于计算密集型任务是一个很好的选择，因为每个进程都有自己的Python解释器和内存空间，可以并行计算。
One More Thing

让我们再深入地看一下concurrent.futures模块，这是一个在Python中同时处理多线程和多进程的更高级的工具。concurrent.futures模
块提供了一个高级的接口，将异步执行的任务放入到线程或者进程的池中，然后通过future对象来获取执行结果。这个模块使得处理线程和进程变得更简单。
下面是一个例子：

1. from concurrent.futures import ThreadPoolExecutor, as_completed
3. def worker(x):
4.     return x * x
6. with ThreadPoolExecutor(max_workers=4) as executor:
7.     futures = {executor.submit(worker, x) for x in range(10)}
8.     for future in as_completed(futures):
9.         print(future.result())

复制代码

这个代码创建了一个线程池，并且向线程池提交了10个任务。然后，通过future对象获取每个任务的结果。这里的as_completed函数提供了一种处理完成的future的方式。
通过这种方式，你可以轻松地切换线程和进程，只需要将ThreadPoolExecutor更改为ProcessPoolExecutor。
无论你是处理IO密集型任务还是计算密集型任务，Python的多线程和多进程都提供了很好的解决方案。理解它们的运行机制和适用场景，可以帮助你更好地设计和优化你的程序。

如有帮助，请多关注
个人微信公众号：【Python全视角】
TeahLead_KrisChang，10+年的互联网和人工智能从业经验，10年+技术和业务团队管理经验，同济软件工程本科，复旦工程管理硕士，阿里云认证云服务资深架构师，上亿营收AI产品业务负责人。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！