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

已于 2024-09-01 14:05:51 修改
阅读量612 收藏 9
点赞数 14
分类专栏： Python 文章标签： python
于 2024-08-25 21:41:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/daoshen1314/article/details/141535265
版权

在 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)
小鱼爱吃火锅
关注
专栏目录
Python多线程threading和多进程multiprocessing的区别及代码实现
走过路过不要错过
04-21 3390
1. 多线程threading import time from threading import Thread def thread_read(data): while True: print('read data:', data) def thread_write(data): i = 1 while True: data[0] = i data[1] = i + 1 print('write data:', data) i += 1 if __name_
Python的多线程threading和多进程multiprocessing
12-10 518
python中的多线程就是在一个进程中存在着多个线程，在线程中，所有的线程都是共享资源的，线程之间的数据通信很简单。但是python仅支持一个线程的运行，因为python中存在一个全局解释器锁GIL（global interpreter lock），正是这个锁能保证同一时刻只有一个线程在运行，所以多线程依旧像是单线程的运行。 GIL无疑就是一把对多线程有影响的全局锁，解决它对多线程的影响，不单单是释放GIL这么简单。GIL使得对象模型都是可以并发访问。GIL全局解释器锁解决多线程之间数据完整性和状态同步的问
通用多线程模块（jdk线程池的运用）
03-14
介绍一个通用多线程服务模块。是利用jdk线程池，多线程并行处理多任务，以提高执行效率。
python的threading和multiprocessing模块初探
热门推荐
zhaozhi406的专栏
11-01 3万+
前言 这两天为了做一个小项目，研究了一下python的并发编程，所谓并发无非多线程和多进程，最初找到的是threading模块，因为印象中线程“轻量...”，“切换快...”，“可共享进程资源...”等等，但是没想到这里水很深，进而找到了更好的替代品multiprocessing模块。下面会讲一些使用中的经验。 后面出现的代码都在ubuntu10.04 + python2.6.5的环境下测试
Python多线程 threading 和多进程 multiprocessing
ZhengrongYue的博客
07-18 1604
Python多线程 threading 和多进程 multiprocessing
python threading multiprocess_Python的threading和multiprocessing
weixin_39843677的博客
12-17 159
Python的threading基础用法, 通过 threading.Thread() 创建线程, 然后 start() 和 join()import timeimport threadingdef do_something(seconds):print('Sleeping...')time.sleep(seconds)print('Done')start = time.perf_counter(...
Python的multiprocessing多进程
rbin_yao的博客
06-29 196
Python的multiprocessing多线程 import multiprocessing import time def task1(no): while True: print('task%d run.'%(no)) time.sleep(1) def task2(no): while True: print('task%d run.'%(no)) time.sleep(1) def main(): t1
Python多线程threading和multiprocessing模块实例解析
09-20
Python中实现多线程的主要方式是通过threading模块和multiprocessing模块。在详细解析这两个模块之前，需要先了解进程和线程的基本概念。 进程和线程是操作系统进行资源分配和调度的基本单位。进程是系统进行资源...
并发和并行 | Python中实现多线程 threading 和多进程 multiprocessing
记录学习痕迹的公众号：Piper蛋窝
06-10 6340
深入浅出比喻说明线程与进程，附小白都能看懂的对比试验。
多线程模块
weixin_55205414的博客
03-18 136
Python的多线程模块有两种实现方法 函数 线程类 一【函数】 调用thread模块中的start_new_thread()函数来创建线程，以线程函数的形式告诉线程该做什么 #!/usr/bin/python import thread def f(name): print "this is "+name if __name__=="__main__": thread.start_new_thread(f,("mimi",)) while 1: pass 二【线程类】 调用threadin
多线程模块极度版.ec
06-24
多线程模块极度版.ec 多线程模块 易语言稳定的多线程模块
易语言鱼刺类多线程模块
07-17
易语言鱼刺类多线程模块 易语言鱼刺类多线程模块 易语言鱼刺类多线程模块
Python脚本之Multiprocessing 多线程
weixin_33856370的博客
11-16 194
AAB377E247752DA87288BAF935E442AC ###################################### #!/usr/bin/env python #encoding=utf-8 from multiprocessing import Process,Lock import time,os def say(i): ...
python多线程模块
weixin_42494845的博客
04-06 1200
进程和线程 进程 进程是系统进行资源分配和调度的基本单位，是程序执行时的一个实例。程序运行时系统会创建一个进程，并为它分配资源，一个进程都有它自己的地址空间，使得各个进程之间内存地址相互隔离。进程主要用于管理资源。 线程 线程是操作系统能够进行运算调度的最小单位。一个进程可以包含多个线程，线程间共享进程的所有资源，每个线程也有自己单独的堆栈和局部变量，线程是进程的一个执行流，是CPU调度和分派的基...
python threading multiprocess_Python 线程(threading) 进程(multiprocessing)
weixin_36376765的博客
02-09 333
Python 线程(threading) 进程(multiprocessing)最近学了两个python库，一个负责管理线程，一个负责管理进程，原来一直写的都 是些单线程的程序，虽然web也关于并发和多涉及到线程，但都是框架管理的，学习>过后发现了解线程和进程对python的web开发也有一定帮助。下面先谈谈这对python对线程和进程的支持再谈谈对这两个库的应用。python对线程的支持并...
多线程编程 - threading 模块
既然选择了远方 便只顾风雨兼程 - 永强
05-11 354
多线程编程 - threading 模块 更高级别的是 threading 模块。除了 Thread 类以外，该模块还包括许多非常好用的同步机制。 threading 模块的对象 Thread() 类同样包含某种同步机制，所以锁原语的显式使用不再是必需的了。 barrier ['bærɪə]：n. 障碍物，屏障，界线 vt. 把...关入栅栏 semaphore ['seməfɔː]：n. 信号...
Python并发编程：多线程（threading模块）
最新发布
互联网架构小马的博客
08-27 994
多线程是一种并发编程方式，它允许在一个进程内同时运行多个线程，从而提高程序的运行效率。线程是轻量级的进程，拥有自己的栈空间，但共享同一个进程的内存空间。本文详细介绍了Python的threading模块，包括线程的创建、线程同步、线程池的使用，并通过多个示例展示了如何在实际项目中应用这些技术。通过学习这些内容，您应该能够熟练掌握Python中的多线程编程，提高编写并发程序的能力。多线程编程可以显著提高程序的并发性能，但也带来了新的挑战和问题。
模块10多线程
weixin_55680204的博客
06-21 104
进程指正在运行的程序。确切的来说，当-一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。。 2、线程: 线程是进程中的一个执行单元，负责当前进程中程序的 执行，一个进程中至少有一 一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。。3、多线程:。 即就是-一个程序中有多个线程在同时执行。 4、区分单线程和多线程. ●单线程程序:即，若有多个任务只能依次执行。当上一个 任务执行结束后，下一个任务开始执行。 名线程程序，即，若有名个任各可以同时执行
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小鱼爱吃火锅

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值