多任务编程可以通过多种方式实现，具体选择哪种方式取决于你的应用需求和运行环境。以下是几种常见的多任务编程方法：
多进程模式
使用`multiprocessing`模块来创建多个进程，每个进程可以独立运行一个任务。这种方式适用于CPU密集型任务，可以充分利用多核CPU的资源。
示例代码：
```python
import multiprocessing
def task1():
print("Task 1 is running")
def task2():
print("Task 2 is running")
if __name__ == "__main__":
p1 = multiprocessing.Process(target=task1)
p2 = multiprocessing.Process(target=task2)
p1.start()
p2.start()
p1.join()
p2.join()
```
多线程模式
使用`threading`模块来创建多个线程，这些线程可以并发执行，适用于I/O密集型任务，可以提高程序的响应速度。
示例代码：
```python
import threading
def task1():
print("Task 1 is running")
def task2():
print("Task 2 is running")
if __name__ == "__main__":
t1 = threading.Thread(target=task1)
t2 = threading.Thread(target=task2)
t1.start()
t2.start()
t1.join()
t2.join()
```
多进程+多线程模式
结合多进程和多线程的优势，可以在每个进程中创建多个线程，进一步提高程序的并发处理能力。
示例代码：
```python
import multiprocessing
import threading
def task1():
print("Task 1 is running in process", multiprocessing.current_process().pid)
def task2():
print("Task 2 is running in process", multiprocessing.current_process().pid)
if __name__ == "__main__":
p1 = multiprocessing.Process(target=task1)
p2 = multiprocessing.Process(target=task2)
t1 = threading.Thread(target=task1)
t2 = threading.Thread(target=task2)
p1.start()
p2.start()
t1.start()
t2.start()
p1.join()
p2.join()
t1.join()
t2.join()
```
事件驱动编程
使用事件驱动编程模型，如`asyncio`模块，可以在单线程中实现并发执行多个任务。
示例代码：
```python
import asyncio
async def task1():
print("Task 1 is running")
await asyncio.sleep(1)
print("Task 1 is done")
async def task2():
print("Task 2 is running")
await asyncio.sleep(1)
print("Task 2 is done")
async def main():
task1_future = asyncio.create_task(task1())
task2_future = asyncio.create_task(task2())
await task1_future
await task2_future
asyncio.run(main())
```
协程编程
使用协程编程模型，如`gevent`或`greenlet`，可以在单线程中实现高效的并发执行多个任务。
示例代码（使用`gevent`）：
```python
from gevent import monkey
monkey.patch_all()
import gevent
def task1():
print("Task 1 is running")
gevent.sleep(1)
print("Task 1 is done")
def task2():
print("Task 2 is running")
gevent.sleep(1)
print("Task 2 is done")
gevent.joinall([gevent.spawn(task1), gevent.spawn(task2)])
```
选择合适的多任务编程方法需要根据具体的应用场景和需求来决定。多进程适合CPU密集型任务，多线程适合I/O密集型任务，而事件驱动和协程编程则适合需要高并发