39.python之创建进程

最新推荐文章于 2024-03-19 21:31:27 发布
最新推荐文章于 2024-03-19 21:31:27 发布
阅读量2.1k 收藏 16
点赞数
分类专栏： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41917061/article/details/119807349
版权

进程概念

进程

  • 进程是程序的一次执行过程，是一个动态概念，是程序在执行过程中分配和管理资源的基本单位，每一个进程都有一个自己的地址空间，至少有 5 种基本状态，它们是：初始态，执行态，等待状态，就绪状态，终止状态。
  • 例如每打开一个软件，或者每执行一个python脚本都是启动一个进程
  • 启动进程会占用cpu和内存

多进程

  • 就是同时启动多个软件（进程）
  • 例如手机系统启动多个软件，手机系统属于主进程，启动的多个软件属于子进程
  • 多个进程同时在执行程序时，他们之间互不干扰，各自执行自己的业务逻辑

进程的创建模块：模块multiprocessing的Process类

创建进程：

from multiprocessing import Process
p = Process(target,args,kwargs,name,group)

或者:
    
import multiprocessing
p = multiprocessing.Process(target,args,kwargs,name,group)

参数：

  • target：表示这个进程实例所调用对象；
  • args：表示调用对象的位置参数元组；
  • kwargs：表示调用对象的关键字参数字典；
  • name：为当前进程实例的别名；
  • group：大多数情况下用不到；

创建进程的2种方式

方式1：通过Process类可以创建一个进程对象，然后使用start开启进程

import os
import multiprocessing

def test1():
    print(f'test1,进程号是：{os.getpid()}')
def test2(name, age, like):
    print(f'test2,name={name},age={age},like={like},进程号是：{os.getpid()}')

if __name__ == '__main__':
    t1 = multiprocessing.Process(target=test1)
    t1.start()
    t2 = multiprocessing.Process(target=test2, args=('张三', 18, '跑步'))
    t2.start()

结果：
在这里插入图片描述

方式2：
通过子类继承Process类，子类中必须有run方法，里面实现进程功能
创建实例化对象后，调用对象的start方法，会执行run中的代码

import os
from multiprocessing import Process

class Test(Process):
    # 因为Process类本身也有__init__方法，这个子类相当于重写了这个方法，
    # 但这样就会带来一个问题，我们并没有完全的初始化一个Process类，所以就不能使用从这个类继承的一些方法和属性，
    # 最好的方法就是将继承类本身传递给Process.__init__方法，完成这些初始化操作
    def __init__(self, name, age, like):
        Process.__init__(self)
        self.name = name
        self.age = age
        self.like = like

    def run(self):
        print(f'name={self.name},age={self.age},like={self.like},进程号是：{os.getpid()}')

if __name__ == '__main__':
    t = Test('张三', 18, '跑步')
    t.start()

结果：
在这里插入图片描述

Process类常用方法

在这里插入图片描述

  • start():启动进程，并调用该子进程中的p.run()
  • run():进程启动进运行的方法，就是它去调用target指定的函数，我们自定义类的类中一定要实现该方法。
  • terminate():强制终止进程。不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用此方法需要小心：如果此进
  • 还保存了一个锁那么也将不会释放这个锁，进而导致死锁。
  • is_alive():判断进程是否是“活着”的状态。
  • join(timeout):让主线程等待某一子进程结束，才继续执行主进程。timeout是可选的超时时间。超过一个时间主进程就不等待了。
  • kill()：终止当前进程，使其立即退出

多进程的问题：

  • 通过进程模块执行的函数无法获取返回值
  • 多个进程同时修改文件可能会出现错误
  • 进程数量太多可能会造成资源不足，甚至死机等情况

注：

  • os.getpid()：获取当前进程id
  • os.getppid()：获取父进程id

例1：使用单进程

import os
import time

def test1():
    for i in range(3):
        print(f'a={i},进程号是：{os.getpid()}')
        time.sleep(1)

def test2():
    for i in range(3):
        print(f'b={i},进程号是：{os.getpid()}')
        time.sleep(1)

if __name__ == '__main__':
    # 开始时间
    start_time = time.time()
    test1()
    test2()
    # 结束时间
    now_time = time.time()
    # 时间间隔
    time = now_time - start_time
    print(f'时间间隔：{time},进程号是：{os.getpid()}')

结果：进程号始终都是5628，说明是单进程执行的，所以最后的间隔时间是6s左右
在这里插入图片描述

例2：函数test1创建一个进程

import os
import time
import multiprocessing

def test1():
    for i in range(3):
        print(f'test1={i},进程号是：{os.getpid()}')
        time.sleep(1)

def test2():
    for i in range(3):
        print(f'test2={i},进程号是：{os.getpid()}')
        time.sleep(1)

if __name__ == '__main__':
    # 开始时间
    start_time = time.time()
    # 创建一个线程
    a = multiprocessing.Process(target=test1)
    # 开启线程
    a.start()
    test2()
    # 结束时间
    now_time = time.time()
    # 时间间隔
    time = now_time - start_time
    print(f'时间间隔：{time},进程号是：{os.getpid()}')

结果：

  • 进程16368执行了开始时间、test2函数、结束时间、最后打印print
  • 进程9327执行了test1函数
  • 这2个进程是同时执行的，所以最后的的间隔时间大概是3s
    在这里插入图片描述

例3：2个函数分别设置进程

import os
import time
import multiprocessing

def test1():
    for i in range(3):
        print(f'test1={i},进程号是：{os.getpid()}')
        time.sleep(1)

def test2():
    for i in range(3):
        print(f'test2={i},进程号是：{os.getpid()}')
        time.sleep(1)

if __name__ == '__main__':
    # 开始时间
    start_time = time.time()
    # 创建2个进程
    a = multiprocessing.Process(target=test1)
    b = multiprocessing.Process(target=test2)
    # 执行进程a和b
    for i in (a, b):
        i.start()
    # 结束时间
    now_time = time.time()
    # 时间间隔
    time = now_time - start_time
    print(f'时间间隔：{time},进程号是：{os.getpid()}')

结果：

  • 进程15960执行了开始时间和结束时间，以及最后的打印时间间隔
  • 进程9488执行了test1函数
  • 进程16616执行了test2函数
  • 这3个进程是同时执行的，所以打印的时间接近0s
    在这里插入图片描述

例4：阻塞其中一个子进程，等待它执行结束后再执行其他的

import os
import time
import multiprocessing

def test1():
    for i in range(3):
        print(f'test1={i},进程号是：{os.getpid()}')
        time.sleep(1)

def test2():
    for i in range(3):
        print(f'test2={i},进程号是：{os.getpid()}')
        time.sleep(1)

if __name__ == '__main__':
    # 开始时间
    start_time = time.time()
    # 创建进程
    a = multiprocessing.Process(target=test1)
    # 执行进程
    a.start()
    # 阻塞进程
    a.join()
    b = multiprocessing.Process(target=test2)
    b.start()
    # 结束时间
    now_time = time.time()
    # 时间间隔
    time = now_time - start_time
    print(f'时间间隔：{time},进程号是：{os.getpid()}')

结果：

  • 进程5152执行了test1函数
  • 进程4428和进程16136是在进程5152执行结束后才开始同时执行的
    在这里插入图片描述

例5：阻塞2个进程，等待他们执行结束后再执行其他的

import os
import time
import multiprocessing

def test1():
    for i in range(3):
        print(f'test1={i},进程号是：{os.getpid()}')
        time.sleep(1)

def test2():
    for i in range(3):
        print(f'test2={i},进程号是：{os.getpid()}')
        time.sleep(1)

if __name__ == '__main__':
    # 开始时间
    start_time = time.time()
    # 创建一个线程
    a = multiprocessing.Process(target=test1)
    b = multiprocessing.Process(target=test2)
    # 同时开始执行2个子进程
    for i in (a, b):
        i.start()
    # 阻塞2个进程
    for j in (a, b):
        i.join()
    # 结束时间
    now_time = time.time()
    # 时间间隔
    time = now_time - start_time
    print(f'时间间隔：{time},进程号是：{os.getpid()}')

结果：

  • 进程576和进程14596是同时执行的
  • 2个子进程执行结束后才开始执行进程10744
    在这里插入图片描述

例6：杀死一个进程

import os
import time
import multiprocessing

def test1():
    for i in range(3):
        print(f'test1={i},进程号是：{os.getpid()}')
        time.sleep(1)

def test2():
    for i in range(3):
        print(f'test2={i},进程号是：{os.getpid()}')
        time.sleep(1)

if __name__ == '__main__':
    # 开始时间
    start_time = time.time()
    # 创建一个线程
    a = multiprocessing.Process(target=test1)
    b = multiprocessing.Process(target=test2)
    # 同时开始执行2个子进程
    for i in (a, b):
        i.start()
    # 杀死进程
    a.kill()
    # 结束时间
    now_time = time.time()
    # 时间间隔
    time = now_time - start_time
    print(f'时间间隔：{time},进程号是：{os.getpid()}')

结果：

  • 执行test1的进程被杀死，没有执行
    在这里插入图片描述
蜻蜓轻停青亭倾听听雨声
关注
  • 0
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python使用multiprocessing创建进程的方法
09-21
主要介绍了Python使用multiprocessing创建进程的方法,实例分析了multiprocessing模块操作进程的相关技巧,需要的朋友可以参考下
python创建进程fork用法
12-23
本文实例讲述了python创建进程fork用法。分享给大家供大家参考。具体分析如下： #!coding=utf-8 import os ,traceback import time ''' fork()系统调用是Unix下以自身进程创建子进程的系统调用， 一次调用，两次...
探究Python中创建进程的常用方式
m0_70911440的博客
02-10 2149
multiprocessing`模块、`concurrent.futures`模块、`subprocess`模块和`os`模块提供了丰富的工具和方法，帮助我们更好地创建和管理进程，并实现多任务处理和并发执行的功能。在上面的示例中，我们创建了一个包含3个工作进程的进程池`pool`，并使用`map`方法将一个函数`square`应用到一个列表上，实现对列表中所有元素的并发处理。在上面的示例中，我们使用`os.fork`函数创建了一个子进程，并根据返回值的不同分别执行了父进程和子进程的代码。
Python: 如何创建进程
Ethan_Rich的博客
12-16 361
在 Python 中，您可以使用模块来创建进程。以下是使用在这个示例中，函数将在一个新的进程中执行。类用于创建一个新的进程，其中的target参数指定了要在新进程中执行的函数。要确保主程序（main program）在启动进程时，只有在主程序执行时才会创建新的进程，而不是在导入模块时，可以使用语句。这是因为在 Windows 平台上，创建新进程时必须确保主程序运行在一个__main__模块中。
Python之创建进程
最新发布
banliyaoguai的博客
03-19 178
注：注释是对代码的一些解释。
Python创建进程的四种方式
二进制杯莫停的博客
01-02 2195
Python创建进程的四种方式 进程,首先理解进程的概念，假如我们的电脑内存大小是一定的，要开启多个软件，内存的占用就会越来越大，计算机有自己的处理方式。例如时间片轮转，优先级调度等。如果内存当前被占用大部分的空间，开启的软件过多，其他软件也要得到计算机的内存空间，这时候内存就会轮番调度。这个时间间隔是非常短暂的给人的感觉就是多个软件在一起执行。 Python中创建多进程。Python的OS模块封...
python中进程的几种创建方式
Python热爱者的博客
05-18 512
在新创建的子进程中，会把父进程的所有信息复制一份，它们之间的数据互不影响。
python进程教程,python创建进程教学
sun13047140038的博客
08-09 484
如果block使用默认值，且没有设置timeout（单位秒），消息列队如果为空，此时程序将被阻塞（停在读取状态），直到从消息列队读到消息为止，如果设置了timeout，则会等待timeout秒，若还没读取到任何消息，则抛出"Queue.Empty"异常；开启过多的进程并不能提高你的效率，反而会降低你的效率，假设有500个任务，同时开启500个进程，这500个进程除了不能一起执行之外（cpu没有那么多核），操作系统调度这500个进程，让他们平均在4个或8个cpu上执行，这会占用很大的空间。
python创建系统进程
qq_44290699的博客
08-13 1124
掌握导入python的multiprocessing包，定义函数创建单个进程，创建多个进程的方法，并理解守护进程、进程阻塞的方法；
Python 创建子进程模块subprocess详解
09-22
主要介绍了Python 创建子进程模块subprocess详解,本文详细讲解了subprocess模块的方法、参数、使用实例等,需要的朋友可以参考下
python进程教程,python创建进程教学.doc
10-01
python进程教程,python创建进程教学
Python进程创建方式
Lance_mu的博客
02-20 460
【代码】Python进程创建方式。锁
python 第15节 进程和线程 （1）进程创建
tangzhilm的博客
02-20 272
python 进程和线程（1）
零基础学python之高级编程(5)---Python中进程的创建（包含详细注释代码）
2301_79795470的博客
03-16 891
我们在进行一个软件开发的过程中,或者编写一个爬虫软件常常会使用默认使用的单进程去爬取数据,但是速度及其的慢,如果我们想提高爬取数据的速度,我们就可以使用创建多进程进行爬取,今天我们就来学习什么是进程以及如何创建多进程和在实战项目中创建.并发编程是在一个程序中同时执行多个独立的任务，这些任务可以是线程、进程或者协程。并发编程的目的是提高系统的吞吐量和响应时间，能够更高效地利用计算机的资源。通过并发编程，可以将一个大型的任务分解成多个小任务，并且这些小任务可以同时执行，从而提高程序的性能和效率。
17. python从入门到精通——使用进程和线程
weixin_43812198的博客
07-28 255
python中使用进程：在python中调用相应的模块，然后通过这个模块操作操作系统中的进程。
创建一个完全独立的子进程
sinat_28916141的博客
03-24 302
创建一个完全独立的子进程，当主进程退出时子进程依然可以独立存在。需要传递参数时可以配合argprase模块。
[python从入门到实践]绘图显示不出中文字
Java癫疯的博客
11-08 6429
[python从入门到实践]绘图显示不出中文字
python psutil创建进程
01-06
psutil模块提供了创建进程的功能。可以使用psutil.Process()方法来创建一个新的进程对象，并指定要执行的命令和参数。下面是一个示例代码： ```python import psutil # 创建一个新的进程对象 process = psutil....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值