当前位置： 首页 > article >正文

python之多线程和多进程以及threading和multiprocessing模块

article 2024/11/19 7:31:39

在 Python 中，多线程和多进程是实现并发编程的两种主要方式。多线程适用于 I/O 密集型任务，而多进程适用于 CPU 密集型任务。Python 提供了 threading 模块用于多线程编程，提供了 multiprocessing 模块用于多进程编程。

多线程

基本用法

使用 threading 模块可以创建和管理线程。以下是一个简单的多线程示例：

import threading
import time

def worker(name):
    print(f"Thread {name} starting")
    time.sleep(2)
    print(f"Thread {name} finishing")

# 创建线程
thread1 = threading.Thread(target=worker, args=("A",))
thread2 = threading.Thread(target=worker, args=("B",))

# 启动线程
thread1.start()
thread2.start()

# 等待线程完成
thread1.join()
thread2.join()

print("All threads finished")
线程锁

线程锁用于防止多个线程同时访问共享资源，避免竞争条件。以下是一个使用线程锁的示例：

import threading

lock = threading.Lock()
counter = 0

def increment_counter():
    global counter
    for _ in range(100000):
        with lock:
            counter += 1

# 创建线程
threads = []
for i in range(10):
    thread = threading.Thread(target=increment_counter)
    threads.append(thread)
    thread.start()

# 等待线程完成
for thread in threads:
    thread.join()

print(f"Final counter value: {counter}")

多进程

基本用法

使用 multiprocessing 模块可以创建和管理进程。以下是一个简单的多进程示例：

import multiprocessing
import time

def worker(name):
    print(f"Process {name} starting")
    time.sleep(2)
    print(f"Process {name} finishing")

# 创建进程
process1 = multiprocessing.Process(target=worker, args=("A",))
process2 = multiprocessing.Process(target=worker, args=("B",))

# 启动进程
process1.start()
process2.start()

# 等待进程完成
process1.join()
process2.join()

print("All processes finished")
进程锁

进程锁用于防止多个进程同时访问共享资源，避免竞争条件。以下是一个使用进程锁的示例：

import multiprocessing

lock = multiprocessing.Lock()
counter = multiprocessing.Value('i', 0)

def increment_counter():
    for _ in range(100000):
        with lock:
            counter.value += 1

# 创建进程
processes = []
for i in range(10):
    process = multiprocessing.Process(target=increment_counter)
    processes.append(process)
    process.start()

# 等待进程完成
for process in processes:
    process.join()

print(f"Final counter value: {counter.value}")

threading 模块

threading 模块用于在单个进程中创建和管理多个线程。线程是轻量级的，并且共享相同的内存空间。

参数

  1. target:

    • 类型: 可调用对象
    • 说明: 线程启动后要执行的函数或方法。

  2. name:

    • 类型: 字符串
    • 说明: 线程的名称。默认情况下，Python 会自动生成一个唯一的名称。

  3. args:

    • 类型: 元组
    • 说明: 传递给 target 函数的位置参数。

  4. kwargs:

    • 类型: 字典
    • 说明: 传递给 target 函数的关键字参数。

  5. daemon:

    • 类型: 布尔值
    • 说明: 如果设置为 True，则表示该线程是守护线程。当所有非守护线程结束时，程序将退出，即使守护线程仍在运行。
示例
import threading

def worker(arg1, arg2, kwarg1=None):
    print(f"Worker thread is running with arguments: {arg1}, {arg2}, {kwarg1}")

# 创建线程，传递位置参数和关键字参数
thread = threading.Thread(
    target=worker,
    args=(10, 20),
    kwargs={'kwarg1': 'example'},
    name='MyWorkerThread',
    daemon=True
)

# 启动线程
thread.start()

# 等待线程完成
thread.join()
  • target=worker: 指定线程要执行的函数是 worker。
  • args=(10, 20): 传递给 worker 函数的位置参数是 10 和 20。
  • kwargs={'kwarg1': 'example'}: 传递给 worker 函数的关键字参数是 kwarg1='example'。
  • name='MyWorkerThread': 指定线程的名称为 MyWorkerThread。
  • daemon=True: 将线程设置为守护线程。
基本用法
  1. 创建线程
import threading

def worker():
    print("Worker thread is running")

# 创建线程
thread = threading.Thread(target=worker)

# 启动线程
thread.start()

# 等待线程完成
thread.join()
  1. 使用子类创建线程
import threading

class MyThread(threading.Thread):
    def run(self):
        print("MyThread is running")

# 创建线程
thread = MyThread()

# 启动线程
thread.start()

# 等待线程完成
thread.join()
  1. 线程同步

使用 threading.Lock 来确保线程安全。

import threading

lock = threading.Lock()

def worker():
    with lock:
        # 线程安全的代码块
        print("Worker thread is running")

# 创建多个线程
threads = [threading.Thread(target=worker) for _ in range(5)]

# 启动所有线程
for thread in threads:
    thread.start()

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

multiprocessing 模块

multiprocessing 模块用于创建和管理多个进程。每个进程都有自己独立的内存空间，因此适用于 CPU 密集型任务。
在 multiprocessing 模块中，multiprocessing.Process 类用于创建和管理进程。与 threading.Thread 类似，multiprocessing.Process 也接受一些参数来配置进程的行为。以下是 multiprocessing.Process 的常用参数及其解释：

multiprocessing.Process 参数

  1. target:

    • 类型: 可调用对象
    • 说明: 进程启动后要执行的函数或方法。

  2. name:

    • 类型: 字符串
    • 说明: 进程的名称。默认情况下，Python 会自动生成一个唯一的名称。

  3. args:

    • 类型: 元组
    • 说明: 传递给 target 函数的位置参数。

  4. kwargs:

    • 类型: 字典
    • 说明: 传递给 target 函数的关键字参数。

  5. daemon:

    • 类型: 布尔值
    • 说明: 如果设置为 True，则表示该进程是守护进程。当所有非守护进程结束时，程序将退出，即使守护进程仍在运行。
示例
import multiprocessing

def worker(arg1, arg2, kwarg1=None):
    print(f"Worker process is running with arguments: {arg1}, {arg2}, {kwarg1}")

# 创建进程，传递位置参数和关键字参数
process = multiprocessing.Process(
    target=worker,
    args=(10, 20),
    kwargs={'kwarg1': 'example'},
    name='MyWorkerProcess',
    daemon=True
)

# 启动进程
process.start()

# 等待进程完成
process.join()
  • target=worker: 指定进程要执行的函数是 worker。
  • args=(10, 20): 传递给 worker 函数的位置参数是 10 和 20。
  • kwargs={'kwarg1': 'example'}: 传递给 worker 函数的关键字参数是 kwarg1='example'。
  • name='MyWorkerProcess': 指定进程的名称为 MyWorkerProcess。
  • daemon=True: 将进程设置为守护进程。
进程的启动和等待
  • process.start(): 启动进程，调用 worker 函数。
  • process.join(): 等待进程完成。在 process.join() 被调用之前，主进程会被阻塞。
进程间通信

multiprocessing 模块还提供了多种进程间通信的方式，如 Queue、Pipe、Value 和 Array 等。

使用 Queue 进行进程间通信
import multiprocessing

def worker(queue):
    queue.put("Message from worker")

# 创建队列
queue = multiprocessing.Queue()

# 创建进程
process = multiprocessing.Process(target=worker, args=(queue,))

# 启动进程
process.start()

# 等待进程完成
process.join()

# 获取队列中的消息
message = queue.get()
print(message)
使用 Pipe 进行进程间通信
import multiprocessing

def worker(conn):
    conn.send("Message from worker")
    conn.close()

# 创建管道
parent_conn, child_conn = multiprocessing.Pipe()

# 创建进程
process = multiprocessing.Process(target=worker, args=(child_conn,))

# 启动进程
process.start()

# 等待进程完成
process.join()

# 获取管道中的消息
message = parent_conn.recv()
print(message)

通过这些参数和通信方式，你可以灵活地配置和管理进程的行为，并实现进程间的通信。

基本用法
  1. 创建进程
import multiprocessing

def worker():
    print("Worker process is running")

# 创建进程
process = multiprocessing.Process(target=worker)

# 启动进程
process.start()

# 等待进程完成
process.join()
  1. 使用子类创建进程
import multiprocessing

class MyProcess(multiprocessing.Process):
    def run(self):
        print("MyProcess is running")

# 创建进程
process = MyProcess()

# 启动进程
process.start()

# 等待进程完成
process.join()
  1. 进程间通信

使用 multiprocessing.Queue 或 multiprocessing.Pipe 进行进程间通信。

import multiprocessing

def worker(queue):
    queue.put("Message from worker")

# 创建队列
queue = multiprocessing.Queue()

# 创建进程
process = multiprocessing.Process(target=worker, args=(queue,))

# 启动进程
process.start()

# 等待进程完成
process.join()

# 获取队列中的消息
message = queue.get()
print(message)
  1. 进程池

使用 multiprocessing.Pool 来管理进程池。

import multiprocessing

def worker(x):
    return x * x

# 创建进程池
with multiprocessing.Pool(4) as pool:
    results = pool.map(worker, [1, 2, 3, 4, 5])

print(results)

http://www.kler.cn/a/281897.html

相关文章：

  • React Native 全栈开发实战班 - 打包发布之热更新
  • 算法--“汽车加油”问题.
  • STM32 创建一个工程文件（寄存器、标准库）
  • 如何在 Ubuntu 上安装 Jupyter Notebook
  • WTV芯片在智能电子锁语音留言上的应用方案解析
  • Gin HTML 模板渲染
  • Java之二维数组
  • 01 初始化vue3项目
  • pytest断言总结
  • 代码随想录算法训练营第58天|拓扑排序精讲、dijkstra（朴素版）精讲
  • docker内安装miniconda
  • （十六）Flink 状态管理
  • [论文笔记] eval-big-refactor lm_eval 每两个任务使用一个gpu，并保证端口未被使用
  • 网络爬虫--生成假数据
  • uniapp icons图标不显示的问题解决
  • Python爬虫（一文通）
  • Leetcode 131.分割回文串 回溯 C++实现
  • 淘宝扭蛋机小程序，市场发展下的潜在机遇
  • Vue(三)内置指令v-text、html、cloak、once、pre；自定义指令的三种方式、Vue生命周期
  • 如何切换当前使用的IP代理协议
  • 【网络安全】服务基础第一阶段——第二节：Windows系统管理基础----虚拟化IP地址以及用户与组管理
  • 一起搭WPF之列表界面设计
  • [每日一练]查询结果的质量和占比(布尔值的灵活使用)
  • 猫咪掉毛如何清理？希喂、范罗士宠物空气净化器性能比拼
  • 嵌入式UI开发-lvgl+wsl2+vscode系列：11、SSD202移植运行评估demo程序
  • vue ref和reactive区别