Python基础语法（多进程开发&进程建数据共享&进程锁&进程池）

于 2024-09-03 22:16:33 发布
阅读量498 收藏 8
点赞数 17
分类专栏： Python基础语法 文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45213849/article/details/141870196
版权

 Python基础语法文章导航：

  1. Python基础（01初识数据类型&变量）
  2. Python基础（02条件&循环语句）
  3. Python基础（03字符串格式化&运算符&进制&编码）
  4. Python基础（04 基础练习题）
  5. Python数据类型（day05整型&布尔类型&字符串类型）
  6. Python数据类型（06列表&元组）
  7. Python数据类型（07集合&字典&浮点型&None）
  8. Python文件操作01（自动化测试文件相关操作）

  9. Python函数入门（08函数定义&参数&返回值）

  10. Python文件操作02（自动化测试文件相关操作）

  11. Python函数（10生成器&内置函数&推导式）

  12. Python函数（11自定义模块&第三方模块&内置模块）

  13. Python函数（12时间处理&正则表达式）

  14. Python函数（13面向对象）

  15. Python面向对象（15成员&成员修饰符）

  16. Python函数（16进程和线程）

  17. Python基础语法（17多线程&线程锁&单例模式）

目录

一.多进程开发

1. 进程介绍

2. 常见功能

（1）p.start()

（2）p.join()

（3）p.daemon = 布尔值

（4）进程的名称的设置和获取

（5）自定义进程类，直接将线程需要做的事写到run方法中。

（6）CPU个数，程序一般创建多少个进程？（利用CPU多核优势）

二. 进程间数据的共享

1.共享

2.交换

（1）Queues

（2）Pipes

 3. 进程锁

4. 进程池

一.多进程开发

        进程是计算机中资源分配的最小单元；一个进程中可以有多个线程，同一个进程中的线程共享资源；进程与进程之间则是相互隔离。

Python中通过多进程可以利用CPU的多核优势，计算密集型操作适用于多进程。

1. 进程介绍

import multiprocessing

def task(arg):
    pass

def run():
    p1 = multiprocessing.Process(target=task, args=('XXX'), )
    #当前进程准备就绪，等待被CPU调度（工作单元其实是进程中的线程）
    p1.start()

if __name__ == '__main__':
    run()

2. 常见功能

进程的常见方法：

（1）p.start()

  当前进程准备就绪，等待被CPU调度（工作单元其实是进程中的线程）。

（2）p.join()

  等待当前进程的任务执行完毕后再向下继续执行。

def task(arg):
    time.sleep(2)
    print("执行中...")

if __name__ == '__main__':
    multiprocessing.set_start_method("spawn")
    name=[]
    p1=multiprocessing.Process(target=task,args=('xxx',))
    p1.start()
    p1.join()
    time.sleep(2)
    print("继续执行...")
#执行中...
#继续执行...（过了2秒后出现）

（3）p.daemon = 布尔值

  守护进程（必须放在start之前）

  • p.daemon =True，设置为守护进程，主进程执行完毕后，子进程也自动关闭。

  • p.daemon =False，设置为非守护进程，主进程等待子进程，子进程执行完毕后，主进程才结束。

import multiprocessing
import time

def task(arg):
    time.sleep(2)
    print("执行中...")

if __name__ == '__main__':
    multiprocessing.set_start_method("spawn")
    p1=multiprocessing.Process(target=task,args=('xxx',))
    p1.daemon=True
    p1.start()
    time.sleep(2)
    print("继续执行...")
#继续执行...
import multiprocessing
import time

def task(arg):
    time.sleep(2)
    print("执行中...")

if __name__ == '__main__':
    multiprocessing.set_start_method("spawn")
    p1=multiprocessing.Process(target=task,args=('xxx',))
    p1.daemon=False
    p1.start()
    time.sleep(2)
    print("继续执行...")
# 继续执行...
# 执行中...

（4）进程的名称的设置和获取

  • getpid：返回调用进程自身的进程ID。用于标识进程自身。

  • getppid：返回调用进程的父进程ID。用于标识创建调用进程的父进程。

  • multiprocessing.current_process().name：获取当前进程的名字

import multiprocessing
import os
import threading
import time

def func():
    time.sleep(3)

def task(arg):
    for i in range(10):
        t=threading.Thread(target=func)
        t.start()
    #getpid、getppid分别获取当前进程的进程ID和当前进程的父进程ID。
    print(os.getpid(),os.getppid())
    print("线程个数",len(threading.enumerate()))
    time.sleep(2)
    print("当前进程的名称：",multiprocessing.current_process().name)

if __name__ == '__main__':
    print(os.getpid())
    multiprocessing.set_start_method("spawn")
    p1=multiprocessing.Process(target=task,args=('xxx',))
    p1.name="哈哈哈哈哈"
    p1.start()
    print("继续执行...")
# 33756
# 继续执行...
# 22624 33756
# 线程个数 11
# 当前进程的名称： 哈哈哈哈哈

备注：线程计算方法   有1（执行task的线程）+ 10（循环创建的线程）= 11个线程

（5）自定义进程类，直接将线程需要做的事写到run方法中。

import multiprocessing
class MyProcess(multiprocessing.Process):
    def run(self):
        print("执行此进程",self)

if __name__ == '__main__':
    multiprocessing.set_start_method("spawn")
    p=MyProcess(args=('xxx',))
    p.start()
    print("继续执行...")
# 继续执行...
# 执行此进程 <MyProcess name='MyProcess-1' parent=29592 started>

（6）CPU个数，程序一般创建多少个进程？（利用CPU多核优势）

import multiprocessing
n=multiprocessing.cpu_count()
print(n)
#8
import multiprocessing

def task():
    pass

if __name__ == '__main__':
    count=multiprocessing.cpu_count()
    for i in range(count-1):
        p=multiprocessing.Process(target=task)
        p.start()

二. 进程间数据的共享

        进程是资源分配的最小单元，每个进程中都维护自己独立的数据，不共享。

import multiprocessing
def task(data):
    data.append(666)

if __name__ == '__main__':
    data_list=[]
    p=multiprocessing.Process(target=task,args=(data_list,))
    p.start()
    p.join()
    print("主进程：",data_list)
# 主进程： []

        如果想要让他们之间进行共享，则可以借助一些特殊的东西来实现。

1.共享

        multiprocessing.Value: 这是一个类，用来创建可以在不同进程间共享的值。它允许在多进程环境中安全地共享基本数据类型，如整数、浮点数等。

        在 Python 的 multiprocessing 模块中，常见的类型代码包括 'i'（整数）、'd'（浮点数）、'c'（字符，但通常用于 Array 而非 Value）等。

from multiprocessing import Value, Process

def func(n,m1,m2):
    n.value=888
    #将字符串 'a' 使用 utf-8 编码转换成了字节串 b'a'，然后赋值给 m1.value
    m1.value='a'.encode('utf-8')
    m2.value="武"

if __name__ == '__main__':
    #这里的作用是使用Value类从multiprocessing模块创建一个可以在进程间共享的整数值
    #'i': 这个字符代表了要创建的共享变量的类型。在本例中，'i' 表示这是一个整数（integer）类型。
    # 666: 这是共享变量初始化的值。即这个可以在进程间共享的整数的初始值被设定为666。
    num=Value('i',666)
    #创建了一个新的共享内存变量 v1，类型指定为 'c'，这通常表示一个字符类型
    v1=Value('c')
    #试图使用 'u' 类型创建一个 multiprocessing.Value 实例。但是，按照 multiprocessing.Value 的标准用法，类型代码 'u' 并不是直接支持的。
    v2=Value('u')
    p=Process(target=func,args=(num,v1,v2))
    p.start()
    p.join()
    print(num.value)
    print(v1.value)
    print(v2.value)
# 888
# b'a'
# 武
from multiprocessing import Process, Value, Array
def f(data_array):
    data_array[0] = 666

if __name__ == '__main__':
    arr = Array('i', [11, 22, 33, 44]) # 数组：元素类型必须是int; 只能是这么几个数据。
    p = Process(target=f, args=(arr,))
    p.start()
    p.join()
    print(arr[:])
#[666, 22, 33, 44]

        利用 Python 的 multiprocessing 模块中的 Manager 类来创建一个管理器上下文。这个管理器允许您创建可在多个进程之间共享的容器，如列表、字典等。这种方式比直接使用 Value 或 Array 更灵活，尤其适合于需要共享复杂数据结构的场景。 

from multiprocessing import Process, Manager
def f(d, l):
    d[1] = '1'
    d['2'] = 2
    d[0.25] = None
    l.append(666)

if __name__ == '__main__':
    with Manager() as manager:
        d = manager.dict()
        l = manager.list()
        p = Process(target=f, args=(d, l))
        p.start()
        p.join()
        print(d)
        print(l)
# {1: '1', '2': 2, 0.25: None}
# [666]

2.交换

（1）Queues

        使用 queue = multiprocessing.Queue() 这段代码时，创建一个线程或进程安全的队列，这个队列允许您在多个进程之间安全地传递数据，用于进程间通信的一个非常实用的数据结构。

        q.put(i) 表示正向这个队列中放入一个元素 i。这里 i 应该是一个在上下文中已经定义过的变量，意味着即使有多个进程同时尝试向队列中放入或获取数据，队列也能保证数据的正确性和完整性，不会引发冲突。

        一旦数据被放入队列，其他进程可以通过 q.get() 方法来取出这个数据。这是一种典型的“生产者-消费者”模型，其中一个进程（生产者）向队列中放入数据，另一个或多个进程（消费者）从队列中取出并处理数据。

import multiprocessing
def task(q):
    for i in range(10):
        q.put(i)

if __name__ == '__main__':
    queue = multiprocessing.Queue()
    p = multiprocessing.Process(target=task, args=(queue,))
    p.start()
    p.join()
    print("主进程")
    print(queue.get())
    print(queue.get())
    print(queue.get())
    print(queue.get())
    print(queue.get())
# 主进程
# 0
# 1
# 2
# 3
# 4

（2）Pipes

import time
import multiprocessing
def task(conn):
    time.sleep(1)
    conn.send([111, 22, 33, 44])
    data = conn.recv() # 阻塞
    print("子进程接收:", data)
    time.sleep(2)

if __name__ == '__main__':
    parent_conn, child_conn = multiprocessing.Pipe()
    p = multiprocessing.Process(target=task, args=(child_conn,))
    p.start()
    info = parent_conn.recv() # 阻塞
    print("主进程接收：", info)
    parent_conn.send(666)
# 主进程接收： [111, 22, 33, 44]
# 子进程接收: 666

 3. 进程锁

如果多个进程抢占式去做某些操作时候，为了防止操作出问题，可以通过进程锁来避免。

        lock = multiprocessing.RLock() 时，您初始化了一个可重入锁（Reentrant Lock），这是 multiprocessing 模块提供的一个同步原语。可重入锁允许同一个进程多次获得同一个锁，而不会发生死锁。这对于需要在多进程中保护共享资源的情况非常有用，尤其是当某个进程可能在其持有锁的期间再次请求同一把锁时。

        在每个进程中，对于那些需要互斥访问的资源，您需要在访问之前获取锁（lock.acquire()），并在访问完毕后释放锁（lock.release()）

import time
import multiprocessing

def task(lock):
    print("开始")
    lock.acquire()
    # 假设文件中保存的内容就是一个值：10
    with open('f1.txt', mode='r', encoding='utf-8') as f:
        current_num = int(f.read())
    print("排队抢票了")
    time.sleep(0.5)
    current_num -= 1

    with open('f1.txt', mode='w', encoding='utf-8') as f:
        f.write(str(current_num))
    lock.release()

if __name__ == '__main__':
    multiprocessing.set_start_method("spawn")
    lock = multiprocessing.RLock()  # 进程锁
    for i in range(10):
        p = multiprocessing.Process(target=task, args=(lock,))
        p.start()
    # spawn模式，需要特殊处理。
    time.sleep(7)
# 开始
# 排队抢票了
# 开始
# 开始
# 开始
# 开始
# 开始
# 开始
# 开始
# 开始
# 开始
# 排队抢票了
# 排队抢票了
# 排队抢票了
# 排队抢票了
# 排队抢票了
# 排队抢票了
# 排队抢票了
# 排队抢票了
# 排队抢票了

4. 进程池

注意：如果在进程池中要使用进程锁，则需要基于Manager中的Lock和RLock来实现。

        通过使用 manager = multiprocessing.Manager() 创建的管理器，您能够创建可在多个进程间共享的同步对象，如锁。因此，lock_object = manager.RLock() # Lock 正确地创建了一个可在进程池中各个进程间共享的可重入锁（RLock）。这解决了之前直接使用 multiprocessing.RLock() 时遇到的共享问题，因为 Manager 自动处理了跨进程的数据同步。

import time
import multiprocessing
from concurrent.futures.process import ProcessPoolExecutor

def task(lock):
    print("开始")
    # lock.acquire()
    # lock.relase()
    with lock:
        # 假设文件中保存的内容就是一个值：10
        with open('f1.txt', mode='r', encoding='utf-8') as f:
            current_num = int(f.read())

        print("排队抢票了")
        time.sleep(1)
        current_num -= 1

        with open('f1.txt', mode='w', encoding='utf-8') as f:
            f.write(str(current_num))

if __name__ == '__main__':
    pool = ProcessPoolExecutor()
    # lock_object = multiprocessing.RLock() # 不能使用
    manager = multiprocessing.Manager()
    lock_object = manager.RLock() # Lock
    for i in range(10):
        pool.submit(task, lock_object)
# 开始
# 排队抢票了
# 开始
# 开始
# 开始
# 开始
# 开始
# 开始
# 开始
# 排队抢票了
# 开始
# 排队抢票了
# 开始
# 排队抢票了
# 排队抢票了
# 排队抢票了
# 排队抢票了
# 排队抢票了
# 排队抢票了
# 排队抢票了

 

 

小彭向前冲
关注
  • 17
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python基于joblib的并行计算&进程&线程&multiprocessing多核并行计算
猫敷雪
12-19 1471
总的来说，joblib是一个非常适用于需要大规模并行处理和缓存重复计算结果的任务的库，特别是在数据密集型的应用中，如机器学习、数据预处理和科学计算。X, y,这段代码的意思非常简单，即是用n_jobs个CPU来计算函数，其中参数为而这里只有作为被枚举的变量，其它参数始终保持不变。至于里为何要用clone函数是因为如果直接将传入的话，这个模型在外部也将会被改变。具体原因可以参看其它文档。
python多进程共享对象_python学习笔记——多进程中共享内存Value & Array
weixin_39851307的博客
03-02 809
1 共享内存基本特点：(1)共享内存是一种最为高效的进程间通信方式，进程可以直接读写内存，而不需要任何数据的拷贝。(2)为了在多个进程间交换信息，内核专门留出了一块内存区，可以由需要访问的进程将其映射到自己的私有地址空间。进程就可以直接读写这一块内存而不需要进行数据的拷贝，从而大大提高效率。(文件映射)(3)由于多个进程共享一段内存，因此也需要依靠某种同步机制。优缺点：优点：快速在进程间传递数据缺...
Python 多进程&多线程&线程池&进程池&协程
喵酱
02-26 3199
Python 多进程&多线程&线程池&进程池&协程
Python-多进程(进程,锁,通讯,进程池)
weixin_45203607的博客
10-17 1400
在多线程一文中，我们说了因为 GIL 的原因，CPython 解释器下的多线程牺牲了并行性，为此 Python 提供了多进程模块 multiprocessing，该模块同时提供了本地和远程并发，使用子进程代替线程，可以有效的避免 GIL 带来的影响，能够充分发挥机器上的多核优势，可以实现真正的并行效果，并且它与 threading 模块的 API 基本类似，使用起来也比较方便。但如果池中的进程数已经达到规定最大值，那么该请求就会等待，直到池中有进程结束，才会创建新的进程来它。
深入探究Python多进程编程：Multiprocessing模块基础与实战
一键难忘的博客
02-25 3706
在Python编程中，多进程处理是一项关键的技术，特别是在需要处理大规模数据或执行耗时任务时。为了充分利用多核处理器的优势，Python提供了`multiprocessing`模块，使得并行编程变得更加容易。本文将深入探讨`multiprocessing`模块的基础知识，并通过实际代码示例演示其在解决实际问题中的应用。
Python中的线程池与进程池：并行编程的高效选择
一键难忘的博客
03-19 3262
在Python编程中，实现并行处理任务是提高程序性能的关键。线程池和进程池是Python中常用的并行编程工具，它们能够有效地利用多核处理器的优势，加速程序的执行。本文将介绍线程池和进程池的基本概念，并通过代码示例和解析说明它们的使用方式和优劣势。
python 多进程共享数据库连接池_tornado多进程+sqlalchemy连接池
weixin_39536010的博客
12-15 552
问题：tornado多进程+sqlalchemy连接池，经常报错：mysql server has gone away原因分析：父进程创建了子进程之后，子进程会使用调用父进程的mysql连接；当这个子进程退出时，连接被关闭；当父进程再创建子进程时，这个子进程同样调用了父进程的mysql连接，而此时mysql连接已经被上一个进程关闭，但当前子进程并不知道这一点，所以就会报错。解决：SQLAlchem...
python 多进程共享内存样例
wc188996的博客
02-16 1101
最近在搞python多进程共享内存，写个样例大家分享一下，主进程创建了3种多进程共享的内存的机制，分别是单值，数组，字符串。并且通过初始化函数将可共享的参数传递给A,B两个类。A类负责读取共享内容，B类负责修改共享内容。
Python 多进程与进程池
一条到晚游泳的鱼
09-01 783
进程：一个程序运行起来后，代码+用到的资源称之为进程，它是操作系统分配资源的基本单元。其也会有并发与并行的状态，与多线程不同的是，多进程会充分利用CPU的资源来执行任务。 进程的状态： 当任务数大于CPU的核数时，部分任务在执行，部分任务在等待执行，因此就会产生不通的状态： 1.就绪状态：运行条件以满足，等待CPU执行。 2.执行状态：CPU正在执行其任务。 3.等待状态：等待某些条件满足，例如一个程序sleep了。 multiprocessing模块 python中的多线程其实并不是真正的多线程，如果想要
Python中的多线程与多进程编程：线程池与进程池的应用
一键难忘的博客
05-23 2817
线程池是一种预先创建一定数量的线程并维护这些线程，以便在需要时重复使用它们的技术。线程池可以减少线程创建和销毁的开销，提高线程的重复利用率。在Python中，可以使用来创建线程池。本文介绍了在Python中使用线程池和进程池来实现并发编程的方法，并提供了相应的代码示例。首先，我们讨论了多线程和多进程的概念及其在并发编程中的应用场景。然后，我们深入探讨了线程池和进程池的工作原理以及它们之间的性能比较。在代码示例部分，我们演示了如何使用线程池和进程池来执行多个任务，其中包括下载多个文件的示例。
对Python的多进程锁的使用方法详解
09-19
在Python多进程编程中正确使用锁是非常重要的，它能够帮助开发者避免并发问题。需要注意的是，由于进程之间的内存不共享，简单地通过参数传递锁并不能确保锁的有效性。本文介绍了几种常见的问题及其解决方案，并提供...
Python多进程入门、分布式进程数据共享实例详解
09-19
### Python多进程入门 Python 的 `multiprocessing` 模块为开发者提供了丰富的工具来实现多进程编程，这对于处理计算密集型任务尤其有用。下面将详细介绍如何使用 Python 创建和管理多进程，并通过具体示例来解释...
Python基于进程池实现多进程过程解析
09-16
Python提供了`multiprocessing`模块来实现多进程，其中进程池`Pool`是常用的一个工具。本篇文章将详细解析如何基于Python的进程池实现多进程。 1. **进程池（Pool）**： `multiprocessing.Pool` 是一个进程池对象...
Python多进程写入同一文件的方法
09-19
在Python编程中，有时我们需要处理大量...总的来说，Python多进程写入同一文件时，可以通过使用锁或回调函数来解决并发访问带来的问题。在实际应用中，应根据具体情况选择合适的方法，同时注意跨平台兼容性和性能优化。
【python】关于判断空值None、判断len()=0，和 if not 的区别
Meggie35的博客
08-28 7326
python的“空”与“无”之辩，关于None，和空数值。在程序中，判断里面没有值和判断东西是不是为空，也是不一样的东西，我们可以往下看看具体的区别。
爬取长篇小说：选择何种IP策略最佳？
KookeeyLena5的博客
08-29 461
在爬取长篇小说时，选择合适的IP策略至关重要。根据目标网站的反爬虫机制、请求频率限制以及爬取需求的不同，可以选择静态IP、动态IP、住宅IP或数据中心IP等不同类型的IP地址。同时，使用代理服务器或VPN等工具可以进一步提高爬取的稳定性和效率。在爬取过程中，应遵循最佳实践，确保爬取行为的合法性和稳定性。
CUDA编程08 - 并行编程思维
最新发布
GPU全栈博主-程序哥
09-02 1051
到目前为止，我们集中于学习并行编程的实用知识，包括CUDA编程接口特性、GPU架构、性能优化技术、并行模式和应用案例研究。在本章中，我们将讨论更为抽象的概念。我们将并行编程概括为一种思维过程，即设计或选择并行算法，并将一个实际问题分解基本的工作单元，这些工作单元可以由所选的算法高效地执行。具备强大思维技能的程序员不仅会分析问题，还会转变实际问题的结构：哪些部分本质上是串行的，哪些部分适合并行执行，以及将前者的部分转移到后者所涉及的一些权衡。
Python 高级特效 - 生成器 ( Generator)
weixin_48591974的博客
08-31 497
生成器是一种一边循环一边计算的机制,通过列表生成式，可以直接创建一个列表，但是受到内存的限制，列表容量是有限的，当列表元素很 大的时候，会很浪费内存空间。所以可以通过生成器 Generator 生成，它的作用相比列表，内存占用少，节约资源
【Python报错已解决】`TypeError: ‘numpy.ndarray‘ object is not callable`
鸽芷咕的博客
09-01 281
在编程中，你是否遇到过尝试调用一个Numpy数组对象时出现了`TypeError: 'numpy.ndarray' object is not callable`的报错？这个问题通常是由于误将Numpy数组当成了一个函数来调用。接下来，我们将分析这个问题并提供解决方案。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值