Python多线程threading和multiprocessing模块实例解析

Python 多线程和多进程模块实例解析

概述

Python 是一种解释型语言，它天然支持多线程和多进程。

在 Python 中，多线程和多进程是通过 threading 和 multiprocessing 两个模块来实现的。这两种技术可以帮助我们实现并发编程，提高代码的执行效率。

Python threading 模块

threading 模块提供了一种在 Python 中创建和管理线程的方式。通过 threading 模块，我们可以在 Python 中创建多个线程，并且控制线程的启动、暂停、恢复和停止等操作。

示例一：创建线程

import threading

# 自定义线程类
class MyThread(threading.Thread):
    def __init__(self, thread_id):
        super().__init__()
        self.thread_id = thread_id

    def run(self):
        for i in range(10):
            print(f"Thread {self.thread_id} - {i}")

# 创建线程
t1 = MyThread(1)
t2 = MyThread(2)

# 启动线程
t1.start()
t2.start()

# 等待线程执行完成
t1.join()
t2.join()

# 输出结果：
# Thread 1 - 0
# Thread 2 - 0
# Thread 1 - 1
# Thread 2 - 1
# Thread 1 - 2
# Thread 2 - 2
# Thread 1 - 3
# Thread 2 - 3
# Thread 1 - 4
# Thread 2 - 4
# Thread 1 - 5
# Thread 2 - 5
# Thread 1 - 6
# Thread 2 - 6
# Thread 1 - 7
# Thread 2 - 7
# Thread 1 - 8
# Thread 2 - 8
# Thread 1 - 9
# Thread 2 - 9

上面的代码中，我们定义了一个 MyThread 线程类，并在其中定义了 run 方法，在 run 方法中执行线程中的任务。然后，我们创建了两个 MyThread 对象 t1 和 t2，启动这两个线程，并等待它们执行完成。

示例二：线程同步

import threading
import time

# 全局变量
count = 0

# 自定义线程类
class MyThread(threading.Thread):
    def __init__(self):
        super().__init__()

    def run(self):
        global count
        for i in range(1000000):
            count += 1
        time.sleep(1)

# 创建多个线程
threads = []
for i in range(10):
    t = MyThread()
    threads.append(t)

# 启动线程
for t in threads:
    t.start()

# 等待所有线程执行完成
for t in threads:
    t.join()

# 输出结果
print(f"count = {count}")

# 输出结果：count = 10000000

上面的代码中，我们定义了一个 MyThread 线程类，并在其中定义了一个 run 方法，该方法对全局变量 count 进行多次加 1 操作。我们创建了 10 个 MyThread 对象，并分别启动这些线程来进行计数。由于 count 是全局变量，多个线程会同时对其进行加 1 操作，因此需要使用锁进行线程同步。

在上面的代码中，我们使用了 threading.Lock() 对象来进行线程同步，具体实现方式是在 MyThread 类和 main 函数中分别加上锁。这样，整个 count 变量的加 1 操作就变得安全了。执行结果表明，10 个线程共同对 count 进行了 10000000 次加 1 操作，最后得到了正确的结果。

Python multiprocessing 模块

multiprocessing 模块提供了一种在 Python 中创建和管理多个进程的方式。通过 multiprocessing 模块，我们可以在 Python 中创建多个进程，并且控制进程的启动、暂停、恢复和停止等操作。

示例一：创建进程

import multiprocessing

# 自定义进程类
class MyProcess(multiprocessing.Process):
    def __init__(self, process_id):
        super().__init__()
        self.process_id = process_id

    def run(self):
        for i in range(10):
            print(f"Process {self.process_id} - {i}")

# 创建进程
p1 = MyProcess(1)
p2 = MyProcess(2)

# 启动进程
p1.start()
p2.start()

# 等待进程执行完成
p1.join()
p2.join()

# 输出结果：
# Process 1 - 0
# Process 2 - 0
# Process 1 - 1
# Process 2 - 1
# Process 1 - 2
# Process 2 - 2
# Process 1 - 3
# Process 2 - 3
# Process 1 - 4
# Process 2 - 4
# Process 1 - 5
# Process 2 - 5
# Process 1 - 6
# Process 2 - 6
# Process 1 - 7
# Process 2 - 7
# Process 1 - 8
# Process 2 - 8
# Process 1 - 9
# Process 2 - 9

上面的代码中，我们定义了一个 MyProcess 进程类，并在其中定义了 run 方法，在 run 方法中执行进程中的任务。然后，我们创建了两个 MyProcess 对象 p1 和 p2，启动这两个进程，并等待它们执行完成。

示例二：进程池

import multiprocessing

# 进程执行函数
def worker(num):
    print("Worker %d" % num)
    return

# 创建进程池
pool = multiprocessing.Pool(processes=4)

# 启动进程
for i in range(10):
    pool.apply_async(worker, (i,))

# 关闭进程池
pool.close()
pool.join()

# 输出结果：
# Worker 0
# Worker 1
# Worker 2
# Worker 3
# Worker 4
# Worker 5
# Worker 6
# Worker 7
# Worker 8
# Worker 9

上面的代码中，我们定义了一个 worker 进程执行函数，该函数接受一个参数 num，输出一个字符串和参数 num。同时，我们创建了一个进程池 pool，该进程池使用 multiprocessing.Pool() 函数来创建，并指定最大进程数为 4。然后，我们使用 pool.apply_async() 函数向进程池提交 10 个任务，每个任务调用 worker 函数，并且传递一个参数 i。最后，我们关闭进程池，并等待所有进程执行完成。执行结果表明，10 个任务被分配给 4 个进程执行，执行结果是按顺序输出的。