【Python基础】进程

最新推荐文章于 2024-04-18 19:32:52 发布
置顶 最新推荐文章于 2024-04-18 19:32:52 发布
阅读量183 收藏
点赞数
分类专栏： Python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_35339990/article/details/107727406
版权
本文介绍了Python中多进程的使用，包括导入进程包、Process类、多进程任务执行、获取进程编号以及进程间参数传递。强调了进程之间不共享全局变量的特点，并展示了主进程如何等待所有子进程执行结束。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

【Python基础】进程

文章目录

学习目标

  • 能够使用多进程完成多任务

多线程的使用

1 导入进程包

#导入进程包
import multiprocessing

2. Process进程类的说明

Process([group [, target [, name [, args [, kwargs]]]]])

  • group：指定进程组，目前只能使用None
  • target：执行的目标任务名
  • name：进程名字
  • args：以元组方式给执行任务传参
  • kwargs：以字典方式给执行任务传参

Process创建的实例对象的常用方法:

  • start()：启动子进程实例（创建子进程）
  • join()：等待子进程执行结束
  • terminate()：不管任务是否完成，立即终止子进程

Process创建的实例对象的常用属性:

name：当前进程的别名，默认为Process-N，N为从1开始递增的整数

3. 多进程完成多任务的代码

import multiprocessing
import time


# 跳舞任务
def dance():
    for i in range(5):
        print("跳舞中...")
        time.sleep(0.2)


# 唱歌任务
def sing():
    for i in range(5):
        print("唱歌中...")
        time.sleep(0.2)

if __name__ == '__main__':
    # 创建跳舞的子进程
    # group: 表示进程组，目前只能使用None
    # target: 表示执行的目标任务名(函数名、方法名)
    # name: 进程名称, 默认是Process-1, .....
    dance_process = multiprocessing.Process(target=dance, name="myprocess1")
    sing_process = multiprocessing.Process(target=sing)

    # 启动子进程执行对应的任务
    dance_process.start()
    sing_process.start()

输出结果

唱歌中...
跳舞中...
唱歌中...
跳舞中...
唱歌中...
跳舞中...
唱歌中...
跳舞中...
唱歌中...
跳舞中...

获取进程编号

1. 获取进程编号的目的

获取进程编号的目的是验证主进程和子进程的关系，可以得知子进程是由那个主进程创建出来的。

获取进程编号的两种操作

  • 获取当前进程编号
  • 获取当前父进程编号

2. 获取当前进程编号

os.getpid() 表示获取当前进程编号

示例代码:

import multiprocessing
import time
import os


# 跳舞任务
def dance():
    # 获取当前进程的编号
    print("dance:", os.getpid())
    # 获取当前进程
    print("dance:", multiprocessing.current_process())
    for i in range(5):
        print("跳舞中...")
        time.sleep(0.2)
        # 扩展:根据进程编号杀死指定进程
        os.kill(os.getpid(), 9)


# 唱歌任务
def sing():
    # 获取当前进程的编号
    print("sing:", os.getpid())
    # 获取当前进程
    print("sing:", multiprocessing.current_process())
    for i in range(5):
        print("唱歌中...")
        time.sleep(0.2)


if __name__ == '__main__':

    # 获取当前进程的编号
    print("main:", os.getpid())
    # 获取当前进程
    print("main:", multiprocessing.current_process())
    # 创建跳舞的子进程
    # group: 表示进程组，目前只能使用None
    # target: 表示执行的目标任务名(函数名、方法名)
    # name: 进程名称, 默认是Process-1, .....
    dance_process = multiprocessing.Process(target=dance, name="myprocess1")
    sing_process = multiprocessing.Process(target=sing)

    # 启动子进程执行对应的任务
    dance_process.start()
    sing_process.start()

执行结果:

main: 70763
main: <_MainProcess(MainProcess, started)>
dance: 70768
dance: <Process(myprocess1, started)>
跳舞中...
sing: 70769
sing: <Process(Process-2, started)>
唱歌中...
唱歌中...
唱歌中...
唱歌中...
唱歌中...

3. 获取当前父进程编号

os.getppid() 表示获取当前父进程编号

示例代码:

import multiprocessing
import time
import os


# 跳舞任务
def dance():
    # 获取当前进程的编号
    print("dance:", os.getpid())
    # 获取当前进程
    print("dance:", multiprocessing.current_process())
    # 获取父进程的编号
    print("dance的父进程编号:", os.getppid())
    for i in range(5):
        print("跳舞中...")
        time.sleep(0.2)
        # 扩展:根据进程编号杀死指定进程
        os.kill(os.getpid(), 9)


# 唱歌任务
def sing():
    # 获取当前进程的编号
    print("sing:", os.getpid())
    # 获取当前进程
    print("sing:", multiprocessing.current_process())
    # 获取父进程的编号
    print("sing的父进程编号:", os.getppid())
    for i in range(5):
        print("唱歌中...")
        time.sleep(0.2)


if __name__ == '__main__':

    # 获取当前进程的编号
    print("main:", os.getpid())
    # 获取当前进程
    print("main:", multiprocessing.current_process())
    # 创建跳舞的子进程
    # group: 表示进程组，目前只能使用None
    # target: 表示执行的目标任务名(函数名、方法名)
    # name: 进程名称, 默认是Process-1, .....
    dance_process = multiprocessing.Process(target=dance, name="myprocess1")
    sing_process = multiprocessing.Process(target=sing)

    # 启动子进程执行对应的任务
    dance_process.start()
    sing_process.start()
main: 70860
main: <_MainProcess(MainProcess, started)>
dance: 70861
dance: <Process(myprocess1, started)>
dance的父进程编号: 70860
跳舞中...
sing: 70862
sing: <Process(Process-2, started)>
sing的父进程编号: 70860
唱歌中...
唱歌中...
唱歌中...
唱歌中...
唱歌中...

进程执行带有参数的任务

1. 进程执行带有参数的任务的介绍

前面我们使用进程执行的任务是没有参数的，假如我们使用进程执行的任务带有参数，如何给函数传参呢?

Process类执行任务并给任务传参数有两种方式:

  • args 表示以元组的方式给执行任务传参
  • kwargs 表示以字典方式给执行任务传参

2. args参数的使用

示例代码:

import multiprocessing
import time


# 带有参数的任务
def task(count):
    for i in range(count):
        print("任务执行中..")
        time.sleep(0.2)
    else:
        print("任务执行完成")


if __name__ == '__main__':
    # 创建子进程
    # args: 以元组的方式给任务传入参数
    sub_process = multiprocessing.Process(target=task, args=(5,))
    sub_process.start()

执行结果:

任务执行中..
任务执行中..
任务执行中..
任务执行中..
任务执行中..
任务执行完成

3. kwargs参数的使用

示例代码:

import multiprocessing
import time


# 带有参数的任务
def task(count):
    for i in range(count):
        print("任务执行中..")
        time.sleep(0.2)
    else:
        print("任务执行完成")


if __name__ == '__main__':
    # 创建子进程

    # kwargs: 表示以字典方式传入参数
    sub_process = multiprocessing.Process(target=task, kwargs={"count": 3})
    sub_process.start()

执行结果:

任务执行中..
任务执行中..
任务执行中..
任务执行完成

进程的注意点

1. 进程的注意点介绍

  1. 进程之间不共享全局变量
  2. 主进程会等待所有的子进程执行结束再结束

2. 进程之间不共享全局变量

import multiprocessing
import time

# 定义全局变量
g_list = list()


# 添加数据的任务
def add_data():
    for i in range(5):
        g_list.append(i)
        print("add:", i)
        time.sleep(0.2)

    # 代码执行到此，说明数据添加完成
    print("add_data:", g_list)


def read_data():
    print("read_data", g_list)


if __name__ == '__main__':
    # 创建添加数据的子进程
    add_data_process = multiprocessing.Process(target=add_data)
    # 创建读取数据的子进程
    read_data_process = multiprocessing.Process(target=read_data)

    # 启动子进程执行对应的任务
    add_data_process.start()
    # 主进程等待添加数据的子进程执行完成以后程序再继续往下执行，读取数据
    add_data_process.join()
    read_data_process.start()

    print("main:", g_list)

    # 总结: 多进程之间不共享全局变量

执行结果:

add: 0
add: 1
add: 2
add: 3
add: 4
add_data: [0, 1, 2, 3, 4]
main: []
read_data []

进程之间不共享全局变量的解释效果图:
在这里插入图片描述

3. 进程之间不共享全局变量的小结

  • 创建子进程会对主进程资源进行拷贝，也就是说子进程是主进程的一个副本，好比是一对双胞胎，之所以进程之间不共享全局变量，是因为操作的不是同一个进程里面的全局变量，只不过不同进程里面的全局变量名字相同而已。

4. 主进程会等待所有的子进程执行结束再结束

假如我们现在创建一个子进程，这个子进程执行完大概需要2秒钟，现在让主进程执行0.5秒钟就退出程序，查看一下执行结果，示例代码如下:

import multiprocessing
import time


# 定义进程所需要执行的任务
def task():
    for i in range(10):
        print("任务执行中...")
        time.sleep(0.2)

if __name__ == '__main__':
    # 创建子进程
    sub_process = multiprocessing.Process(target=task)
    sub_process.start()

    # 主进程延时0.5秒钟
    time.sleep(0.5)
    print("over")
    exit()

    # 总结： 主进程会等待所有的子进程执行完成以后程序再退出

执行结果:

任务执行中...
任务执行中...
任务执行中...
over
任务执行中...
任务执行中...
任务执行中...
任务执行中...
任务执行中...
任务执行中...
任务执行中...

说明:

通过上面代码的执行结果，我们可以得知: 主进程会等待所有的子进程执行结束再结束

假如我们就让主进程执行0.5秒钟，子进程就销毁不再执行，那怎么办呢?

  • 我们可以设置守护主进程 或者 在主进程退出之前 让子进程销毁

守护主进程:

  • 守护主进程就是主进程退出子进程销毁不再执行

子进程销毁:

  • 子进程执行结束

保证主进程正常退出的示例代码:

import multiprocessing
import time


# 定义进程所需要执行的任务
def task():
    for i in range(10):
        print("任务执行中...")
        time.sleep(0.2)

if __name__ == '__main__':
    # 创建子进程
    sub_process = multiprocessing.Process(target=task)
    # 设置守护主进程，主进程退出子进程直接销毁，子进程的生命周期依赖与主进程
    # sub_process.daemon = True
    sub_process.start()

    time.sleep(0.5)
    print("over")
    # 让子进程销毁
    sub_process.terminate()
    exit()

    # 总结： 主进程会等待所有的子进程执行完成以后程序再退出
    # 如果想要主进程退出子进程销毁，可以设置守护主进程或者在主进程退出之前让子进程销毁

执行结果:

任务执行中...
任务执行中...
任务执行中...
over
python主进程和子进程_进程与子进程(python3入门)
weixin_39690963的博客
12-06 1675
一、开启进程的两种方式方式一：#方式一：使用函数开启进程from multiprocessing importProcessimporttimedeftask(x):print('%s is running' %x)time.sleep(1)print('%s is done' %x)if __name__ == '__main__':#p1 = Process(target=task, args...
一.进程
FREVOER的博客
09-12 298
一.进程 1.什么是进程 在python程序中,想要实现多任务可以使用进程来完成,进程是实现多任务的一种方式. 2.进程的概念 一个正在运行的程序或者软件就是一个进程，它是操作系统进行资源分配的基本单位，也就是说每启动一个进程，操作系统都会给其分配一定的运行资源(内存资源)保证进程的运行。 3.进程的作用 多进程可以完成多任务,每个进程就好比一家独立的公司,每个公司都各自在运营,每个进程也在各自运行,执行各自的任务. 4.小结 1.进程使操作系统进行资源分配得基本单位 2.进程使python程序中实现多任务
multiprocessing Process子进程会把非main的代码重新再次执行
weixin_42357472的博客
04-18 325
测试下来from funasr import AutoModel非常耗时，如果放在外面启动子进程都会再次执行会非常影响。把只需要执行一遍的逻辑或者python import耗时的包放到main函数里。
【python】多进程中的内存复制
pushiqiang的博客
01-02 6360
比较好奇python对于多进程中copy on write机制的实际使用情况。目前从实验结果来看，python 使用multiprocessing来创建多进程时，无论数据是否不会被更改，子进程都会复制父进程的状态(内存空间数据等)。所以如果主进程耗的资源较多时，不小心就会造成不必要的大量的内存复制，从而可能导致内存爆满的情况。 示例 举个例子，假设主进程读取了一个大文件对象的所有行，然后通
多线程互斥锁信号量
kdttbk的博客
05-22 213
例1：线程加锁import threading import time num=0 def run(n): lock.acquire() global num num+=1 print("task start",n) time.sleep(2) print("task done=&gt;",n,'num=%d'%num) print(thre...
python的multiprocessing模块进程创建、资源回收-Process,Pool
weixin_30877227的博客
09-01 503
python的multiprocessing有两种创建进程的方式，每种创建方式和进程资源的回收都不太相同，下面分别针对Process,Pool及系统自带的fork三种进程分析。 1.方式一：fork() 举例： 1 import os 2 pid = os.fork() # 创建一个子进程 3 os.wait() # 等待子进程结束释放资源 4 pid为0的代表子进程。 缺点...
python基础，python进程和线程
最新发布
11-05
Python基础阶段的学习是构建整个Python知识体系的基石，而深入了解和应用进程与线程则是提升Python编程能力的重要一步。掌握这两种并发编程模型，可以帮助开发者编写出更加高效和强大的应用程序。
python 进程的使用 python基础 提供了python进程的使用示例代码，python2可以直接运行
08-18
进程和线程是操作系统管理和调度的基础。在需要充分利用多核处理器的性能时，通常会使用多进程或多线程技术。在Python中，多进程和多线程库提供了相应的支持。 Python 中的进程 ------------- 在Python中，`...
Python 基础 之 python 进程知识点整理，实现一个简单使用进程池的多进程文件夹文件copy器
12-22
Python 基础 之 python 进程知识点整理，实现一个简单使用进程池的多进程文件夹文件copy器   目录 Python 基础 之 python 进程知识点整理，实现一个简单使用进程池的多进程文件夹文件copy器 一、简单介绍 二、能学...
python基础教程：Python中的进程分支fork和exec详解
12-21
在Python编程中，进程是操作系统资源分配的基本单位，而进程分支则是实现并发执行的一种手段。在Linux系统中，Python可以通过`os.fork()`函数来创建进程分支。`fork()`函数非常独特，它在一个调用中产生两次返回：一...
python多进程 主进程和子进程间共享和不共享全局变量实例
09-17
### Python多进程主进程与子进程间的全局变量共享与非共享 #### 一、引言 在Python中，多进程编程是一种常见的并行处理技术，它允许程序将任务分配到多个独立的...了解这些基础知识对于开发高效的多进程应用至关重要。
python多进程的使用（导包、创建子进程、启动子进程）
IT之一小佬的博客
03-19 974
多进程的使用 1 导入进程包 #导入进程包 import multiprocessing 2. Process进程类的说明 Process([group [, target [, name [, args [, kwargs]]]]]) group：指定进程组，目前只能使用None 【不用设置】 target：执行的目标任务名 【函数名】 name：进程名字 【可以不用设置，设置了也没有用】 args：以元组方式给执行任务传参 【函数没有参数时就不用传参】 kwargs：以字典...
python 子进程Process类的使用
gqixf的博客
06-20 832
感谢作者的总结：https://blog.youkuaiyun.com/miaoqinian/article/details/80062740 Python 提供了multiprocessing模块来开启子进程，并在子进程中执行我们定制的任务。 multiprocessing模块的功能众多，支持子进程，通信，共享数据，执行不同形式的同步，有Process、Queue、Pipe、Lock等组件。 创建进程...
关于python的多进程的一些细节
m0_38043555的博客
11-14 887
不同平台的区别 在 windows平台，python是使用spawn方式创建子进程，即导入当前的脚本作为module运行。在linux平台，则是以fork的方式创建子进程，父进程会拷贝当前的进程信息给子进程，子进程和父进程在异步继续执行。 这两种方式的不同，会导致我们在写代码时需要注意一些细节，对于spawn方式，由于子进程是重新导入一份脚本，所以创建子进程之前的代码也有可能被子进程执行，导致子进程又创建子进程，会出错。我们需要加入if name == 'main’来规避这种意外，即将只希望主进程执行的代
Python创建子进程
azlxxx的博客
08-31 3662
方法1 os.fork() windows上不支持,mac,linux,unix上可以 import os pid = os.fork() # 操作系统自动把父进程的信息资源复制给了子进程，在两个进程中分别返回，父进程返回子进程的ID if pid < 0: print('fork失败') elif pid == 0: # 子进程的pid为 0 print('我是子进程',os.getpid(),'我的父进程',os.getppid()) # os.getpid()获取当前进
python多任务处理
DownDownUP的博客
11-04 438
进程 定义：一个正在运行的程序或者软件就是一个进程，它是操作系统进行资源分配的基本单位，每一个进程都会消耗一定的内存资源。 进程主要是负责索要内存资源，而实际上干活的是线程 一个程序至少有一个进程，一个进程默认有多个线程 没有进程就没有线程。 多进程可以完成多个任务，比如可以同时使用qq聊天和QQ音乐听歌， 多进程的使用 multiprocessing 通过这个包中的Process进程类实现 Process(group,target,) 手动创建进程管理，使用pocess模块 使用步骤： 创建要进
python高级：进程。
It's You--MXL
05-11 330
目录一、 进程的创建。1.1 **MAC和Linux下：**1.2 **Windows下：**1.3 **关于Process的说明：**二、获取进程编号三、进程的注意点3.1 进程之间不共享全局变量3.2 主进程会等待所有的子进程执行结束再结束。 一、 进程的创建。 1.1 MAC和Linux下： import multiprocessing def printf(name,age): print(name,age) #进程的创建 process1 = multiprocessing.Proces
python多任务编程——多进程多线程编程
钟灵毓秀的博客
08-30 339
一、什么是多任务 概念：多任务是指操作系统同一时间内执行多个任务，例如: 现在电脑安装的操作系统都是多任务操作系统，可以同时运行着多个软件，你一边在用浏览器上网，一边在听MP3，一边在用Word赶作业 作用：使用多任务就能充分利用CPU资源，提高程序的执行效率，让你的程序具备处理多个任务的能力。 二、并发和并行 多任务的执行方式： 并发：指的是任务数多余cpu核数，通过操作系统的各种任务调度算法，...
python多进程编程之新建子进程的实现机制
S_o_l_o_n的博客
10-05 551
在Unix系统下，python的multiprocessing模块下，直接通过分支一个新的进程，并调用进程对象的run方法来实现；这就相当于直接复制了父进程当前的状态，然后在此基础上在独立内存中运行。由于需要复制父进程的状态，所以如果父进程本身占用内存较大，那么新建的进程会加倍的增加内存占用。 而在Windows下，python的multiprocessing模块是通...
Python多进程编程基础教程与示例
1. **多进程基础概念** 多进程指的是在操作系统中同时运行多个进程的能力。每一个进程都有自己独立的地址空间，可以看做是程序的一次执行实例。在Python中，由于全局解释器锁（GIL）的存在，CPU密集型任务无法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值