如何让python程序正确高效地并发

如何让Python程序正确高效地并发

在Python中，有许多方式可以实现程序的并发，比如：

• 多线程（使用标准库threading）
• 多进程（使用标准库multiprocessing）
• 协程（使用第三方库asyncio）

而在并发编程中，最关键的是要正确高效地使用锁等同步机制，以避免出现数据竞争等并发问题。下面将详细介绍如何正确高效地使用上述并发编程方式。

多线程

使用threading.Lock实现同步

当多个线程同时访问共享资源（如列表、字典等可变对象）时，容易出现数据竞争问题。为了避免这种问题，需要使用锁机制来保证在某一时刻只有一个线程能够访问共享资源。

import threading

def func(data, lock):
    with lock:
        # 这里是需要使用锁同步的代码块
        data.append(1)
        print(data)

if __name__ == '__main__':
    data = []
    lock = threading.Lock()
    threads = []
    for i in range(10):
        t = threading.Thread(target=func, args=(data, lock))
        threads.append(t)
    for t in threads:
        t.start()
    for t in threads:
        t.join()

在上面的代码中，lock是一个threading.Lock对象，用于同步多个线程对data的访问。在func函数中，使用with lock语句获取锁，然后执行需要同步的代码，这样就保证了只有一个线程能够同时访问data。

使用threading.Event实现线程间通信

在多线程编程中，线程之间的通信也是一个重要的问题。如果一个线程需要等待另一个线程的信号才能继续执行，那么可以使用threading.Event来实现线程间通信。

import threading
import time

def worker(e):
    print('Worker is waiting')
    e.wait()
    print('Worker is working')

if __name__ == '__main__':
    e = threading.Event()
    t = threading.Thread(target=worker, args=(e,))
    t.start()
    time.sleep(1)
    e.set()

在上面的代码中，worker函数中的线程等待e事件的触发。在主线程中，等待1秒后触发e事件，这样worker就能够继续执行。

多进程

使用multiprocessing.Lock实现同步

与多线程类似，多进程也需要使用锁来保护共享资源。不同之处在于，multiprocessing.Lock用于多个进程之间的同步。

import multiprocessing

def func(data, lock):
    with lock:
        # 这里是需要使用锁同步的代码块
        data.append(1)
        print(data)

if __name__ == '__main__':
    manager = multiprocessing.Manager()
    data = manager.list()
    lock = manager.Lock()
    processes = []
    for i in range(10):
        p = multiprocessing.Process(target=func, args=(data, lock))
        processes.append(p)
    for p in processes:
        p.start()
    for p in processes:
        p.join()

在上面的代码中，lock是一个multiprocessing.Lock对象，用于同步多个进程对共享资源data的访问。在func函数中，使用with lock语句获取锁，然后执行需要同步的代码，这样就保证了只有一个进程能够同时访问data。

使用multiprocessing.Queue实现进程间通信

与线程间通信类似，多进程编程中也需要实现进程间通信。multiprocessing.Queue类提供了一个进程安全的队列，可以用于实现进程间通信。

import multiprocessing

def worker(q):
    data = q.get()
    print(data)

if __name__ == '__main__':
    q = multiprocessing.Queue()
    p = multiprocessing.Process(target=worker, args=(q,))
    p.start()
    q.put('Hello, World!')
    p.join()

在上面的代码中，worker进程从队列中取出数据并打印。主进程中先向队列中插入数据，然后等待worker进程处理完成。就像线程间通信一样，使用队列可以实现进程间的同步。