Python多线程与多进程深度解析-连界优站

内容目录

—— 🛠️ 准备工作 🛠️
—— 🧵 Python 多线程 🧵
—— 🚀 Python 多进程 🚀
—— 🚨 常见问题及解决方法 🚨
—— 🌟 结语 🌟

在现代编程中，多线程和多进程是提高程序性能的重要手段。Python 提供了丰富的库来支持多线程和多进程编程。本文将深入探讨 Python 的多线程和多进程，帮助你更好地理解和应用这些技术。

🛠️ 准备工作 🛠️

在开始之前，确保你的系统已经安装了 Python。本文假设你使用的是 Python 3.x 版本。

🧵 Python 多线程 🧵

多线程是一种在同一进程内并发执行多个任务的技术。Python 标准库中的 threading 模块提供了对多线程编程的支持。

1. 创建线程

import threading

def worker(num):
    """线程执行的函数"""
    print(f'Worker: {num}')

# 创建线程
threads = []
for i in range(5):
    t = threading.Thread(target=worker, args=(i,))
    threads.append(t)
    t.start()

2. 线程同步

多线程编程中，线程同步是一个重要的概念。Python 提供了多种同步机制，如 Lock、RLock、Condition、Event 等。

Lock：互斥锁，用于防止多个线程同时访问共享资源。

import threading

lock = threading.Lock()

def increment(counter):
    for _ in range(1000000):
        lock.acquire()
        counter[0] += 1
        lock.release()

counter = [0]
t1 = threading.Thread(target=increment, args=(counter,))
t2 = threading.Thread(target=increment, args=(counter,))
t1.start()
t2.start()
t1.join()
t2.join()
print(f'Final counter value: {counter[0]}')

RLock：可重入锁，允许同一个线程多次获取锁。

import threading

rlock = threading.RLock()

def recursive_function(n):
    if n > 0:
        rlock.acquire()
        print(f'Level: {n}')
        recursive_function(n - 1)
        rlock.release()

rlock.acquire()
recursive_function(3)
rlock.release()

🚀 Python 多进程 🚀

多进程是一种在多个进程间并发执行任务的技术。Python 标准库中的 multiprocessing 模块提供了对多进程编程的支持。

1. 创建进程

import multiprocessing

def worker(num):
    """进程执行的函数"""
    print(f'Worker: {num}')

# 创建进程
processes = []
for i in range(5):
    p = multiprocessing.Process(target=worker, args=(i,))
    processes.append(p)
    p.start()

2. 进程间通信

多进程编程中，进程间通信是一个重要的概念。Python 提供了多种通信机制，如 Queue、Pipe、Manager 等。

Queue：进程间通信的队列。

import multiprocessing

def producer(queue):
    for i in range(10):
        queue.put(i)

def consumer(queue):
    while True:
        item = queue.get()
        if item is None:
            break
        print(f'Consumed: {item}')

queue = multiprocessing.Queue()
p1 = multiprocessing.Process(target=producer, args=(queue,))
p2 = multiprocessing.Process(target=consumer, args=(queue,))

p1.start()
p2.start()
p1.join()

# 发送终止信号
queue.put(None)
p2.join()

Pipe：进程间通信的管道。

import multiprocessing

def sender(conn):
    for i in range(10):
        conn.send(i)
    conn.close()

def receiver(conn):
    while True:
        try:
            msg = conn.recv()
        except EOFError:
            break
        print(f'Received: {msg}')

parent_conn, child_conn = multiprocessing.Pipe()
p1 = multiprocessing.Process(target=sender, args=(child_conn,))
p2 = multiprocessing.Process(target=receiver, args=(parent_conn,))

p1.start()
p2.start()
p1.join()
p2.join()