Python 并发编程之使用多线程和多处理器(Python并发编程实战：多线程与多处理器高效应用)

原创

ithorizon 6个月前 (10-19) 阅读数 18 #后端开发

Python并发编程实战：多线程与多处理器高效应用

一、引言

在软件开发中，并发编程是一种尽也许降低损耗程序性能和响应速度的重要手段。Python提供了多种并发编程的方法，其中多线程和多处理器是最常用的两种。本文将详细介绍怎样在Python中使用多线程和多处理器进行高效应用。

二、多线程编程

多线程编程允许程序同时执行多个任务，尽也许降低损耗程序的执行高效。Python中，使用`threading`模块来实现多线程编程。

2.1 创建线程

创建线程通常有两种行为：通过继承`threading.Thread`类和通过使用`threading.Thread`类的构造函数。


# 通过继承Thread类创建线程
class MyThread(threading.Thread):
    def run(self):
        print("线程开端运行")
# 通过构造函数创建线程
def thread_function():
    print("线程开端运行")
thread1 = MyThread()
thread2 = threading.Thread(target=thread_function)

2.2 线程同步

为了避免线程之间的竞争条件，Python提供了多种同步机制，如锁（Lock）、事件（Event）、条件（Condition）等。


import threading
# 创建锁
lock = threading.Lock()
def thread_function():
    lock.acquire()  # 获取锁
    try:
        # 执行需要同步的操作
        print("线程开端运行")
    finally:
        lock.release()  # 释放锁
# 创建线程
thread1 = threading.Thread(target=thread_function)
thread2 = threading.Thread(target=thread_function)
# 启动线程
thread1.start()
thread2.start()
# 等待线程终止
thread1.join()
thread2.join()

2.3 线程间通信

线程间通信可以使用`threading`模块中的`Queue`实现。`Queue`是一种先进先出（FIFO）的数据结构，可以平安地在多个线程间传递数据。


import threading
import queue
# 创建队列
q = queue.Queue()
def producer():
    for i in range(5):
        q.put(i)
        print(f"生产者生产了：{i}")
def consumer():
    while True:
        item = q.get()
        if item is None:
            break
        print(f"消费者消费了：{item}")
# 创建线程
producer_thread = threading.Thread(target=producer)
consumer_thread = threading.Thread(target=consumer)
# 启动线程
producer_thread.start()
consumer_thread.start()
# 等待线程终止
producer_thread.join()
consumer_thread.join()

三、多处理器编程

Python中的`multiprocessing`模块可以用来创建多进程，从而实现在多核CPU上并行执行任务。与多线程相比，多进程可以更好地利用CPU资源，尽也许降低损耗程序的执行高效。

3.1 创建进程

创建进程通常有两种行为：通过继承`multiprocessing.Process`类和通过使用`multiprocessing.Process`类的构造函数。


# 通过继承Process类创建进程
class MyProcess(multiprocessing.Process):
    def run(self):
        print("进程开端运行")
# 通过构造函数创建进程
def process_function():
    print("进程开端运行")
process1 = MyProcess()
process2 = multiprocessing.Process(target=process_function)

3.2 进程间通信

进程间通信可以使用`multiprocessing`模块中的`Pipe`和`Queue`实现。`Pipe`提供了一个双向通道，可以在两个进程间传递数据；`Queue`与线程中的`Queue`类似，也可以在多个进程间传递数据。


import multiprocessing
# 使用Pipe进行进程间通信
def sender(conn):
    for i in range(5):
        conn.send(i)
        print(f"发送者发送了：{i}")
def receiver(conn):
    while True:
        try:
            item = conn.recv()
            print(f"接收者接收了：{item}")
        except EOFError:
            break
# 创建Pipe
parent_conn, child_conn = multiprocessing.Pipe()
# 创建进程
sender_process = multiprocessing.Process(target=sender, args=(parent_conn,))
receiver_process = multiprocessing.Process(target=receiver, args=(child_conn,))
# 启动进程
sender_process.start()
receiver_process.start()
# 等待进程终止
sender_process.join()
receiver_process.join()