让我们由浅到深----------深刻了解python中进程创建、使用、管理等等。。。。。。

左手的ㄟ右手 2023-10-02 18:25 2阅读 0赞

\*\*

### 什么是进程？ ###

\*\*  
**1、在早期面向过程设计的计算机结构中，过程是程序的基本执行实体；在当代面向线程设计的计算机体系结构中，进程是线程的容器。它是对指令、数据及其组织形式的描述，过程是程序的实体。多通道程序在执行时需要共享系统资源，这就导致了各个程序在执行过程中相互制约，程序的执行呈现出不连续性的特点。  
2、进程是关于数据集的独立程序的运行活动。它可以申请并拥有系统资源，这是一个动态概念和活动实体。它不仅是程序的代码，也是当前活动，由程序计数器的值和处理寄存器的内容表示。  
3、进程是操作系统中最基本、最重要的概念。它是多道程序设计系统出现后引入的一个概念，用来描述系统内部的动态情况，描述系统内部各个程序的活动规律。所有多道程序设计操作系统都基于该过程。过程的本质是多通道程序系统中程序的执行过程。该过程是动态生成的，并动态终止。**

**`看到上面的进程解释是不是非常的晕，事实上我看着也很晕，下面我们就来了解什么是进程吧。`**  
**在我看来进程是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础，进程是程序的实体。进程就是程序。**

--------------------

**`下面让我们用例子来说明一下什么是进程及python中进程如何使用的`**  
\*\*

### 进程例子，了解进程创建和分配 ###

\*\*

# TODO 导入进程的包
    import multiprocessing    # 进程包
    import time
    # 1.work1
    def work():
        for i in range(5):
            print("work正在工作中.....")
            time.sleep(0.2)
    # 2.work2
    def work2():
        for i in range(5):
            print("work2正在工作中......")
            time.sleep(0.2)
    
    if __name__=="__main__":    #  TODO  主进程
        # TODO 两个子进程
        work_process=multiprocessing.Process(target=work,name="work1Process")
        work2_process=multiprocessing.Process(target=work2)
        #   启动子进程任务
        work_process.start()
        work2_process.start()

**运行结果：**

work正在工作中.....
    work2正在工作中......
    work2正在工作中......work正在工作中.....
    
    work正在工作中.....
    work2正在工作中......
    work2正在工作中......
    work正在工作中.....
    work2正在工作中......
    work正在工作中.....

**`运行结果：`**

work2正在工作中......
    work正在工作中.....
    work正在工作中.....work2正在工作中......
    
    work2正在工作中......work正在工作中.....
    
    work2正在工作中......work正在工作中.....
    
    work正在工作中.....work2正在工作中......

**你多次运行会发现每次的运行结果基本上都不相同，是不是很奇怪，那是因为进程是随机分配的，毫无规律可言。**  
**进程有主进程和子进程。例如一个程序中的主函数是最先执行的，调度和分配函数，那么主进程就是主函数**\*\*`if __name__=="__main__":`**，子进程就是被调度（调用）的函数**`work():和work2()`\*\*，**主线程起到控制子线程的作用。**

--------------------

**想要更好的了解代码就要了解进程代码中各个元素的含义，下面让我们来一起看一下。**  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5LiN6Imv5L2_size_20_color_FFFFFF_t_70_g_se_x_16]

work_process=multiprocessing.Process(target=work,name="work1Process")
    work2_process=multiprocessing.Process(target=work2)

**这两行代码，两行都是主函数（主进程）分配两个子进程（被调用的函数）\*\*\*\*`【也可以成为程序中除主函数的其他函数】`**，**target是进程执行的目标函数，也就是这个进程分配的对象，name是进程的名字（不写就默认），可写可不写，不过方便后面查看进程的名字我们将第一个子进程起一个名字。**

work_process.start()

**start 开启进程，work\_process是前面创建（分配）进程的名字，work\_process.start()即为开启创建的work\_process进程。**

\*\*

--------------------

### 获取进程编号 ###

\*\*  
**`multiprocessing.current_process()`** **获取当前进程的名字（name）**  
**`os.getppid()`** **获取父进程**  
**注意：使用os.getppid()要先引入os包（import os），os包一般用于对文件的处理。**

import os     #  一般用于文件处理
    
    
    import multiprocessing    # 进程包
    import time
    # 1.work1
    def work():
        print("当前work：",os.getpid())
        #  TODO  当前的进程名
        print("work:",multiprocessing.current_process())
    
        #  TODO  获取父进程
        print("work的父进程是：",os.getppid())
        for i in range(5):
            print("work正在工作中.....")
            time.sleep(0.2)
    # 2.work2
    def work2():
        for i in range(5):
            #  TODO  当前的进程名
            print("work2:", multiprocessing.current_process())
            #  TODO  获取父进程
            print("work2的父进程是：", os.getppid())
            print("当前work2：", os.getpid())
            print("work2正在工作中......")
            time.sleep(0.2)
    
    if __name__=="__main__":    #  TODO  主进程
        print("main：",os.getpid())
        # TODO 两个子进程
        work_process=multiprocessing.Process(target=work,name="work1Process")
        work2_process=multiprocessing.Process(target=work2)
        #   启动子进程任务
        work_process.start()
        work2_process.start()
    
    
    multiprocessing.Process()

**`运行结果：`**；

main： 12700
    当前work：work2: 31648
     work: <Process name='Process-2' parent=12700 started>
    <Process name='work1Process' parent=12700 started>
    work的父进程是： 12700
    work2的父进程是： work正在工作中.....12700
    
    当前work2： 31856
    work2正在工作中......
    work正在工作中.....
    work2: <Process name='Process-2' parent=12700 started>
    work2的父进程是： 12700
    当前work2： 31856
    work2正在工作中......
    work正在工作中.....
    work2: <Process name='Process-2' parent=12700 started>
    work2的父进程是： 12700
    当前work2： 31856
    work2正在工作中......
    work正在工作中.....
    work2: <Process name='Process-2' parent=12700 started>
    work2的父进程是： 12700
    当前work2： 31856
    work2正在工作中......
    work正在工作中.....
    work2: <Process name='Process-2' parent=12700 started>
    work2的父进程是： 12700
    当前work2： 31856
    work2正在工作中......
    
    Process finished with exit code 0

**我们可以清晰地发现进程的名字和当前进程的父进程。\*\*\*\*`work1Process`和`Process-2`**，\*\***前者是我们自己起的名字，如果没有起会默认为Process-1**。**进程一旦分配除非遇到内存限制，资源不够等特殊情况（程序不能继续执行下去），进程会一直运行下去且进程名不变。也就是说进程名会和我们的名字一样，出生到死亡一辈子都是这个名字，中途改名对应的就是计算机所发生的特殊情况（内存不够、程序出错等原因）**

--------------------

\*\*

### 进程执行带有参数的任务 ###

\*\*  
**进程执行传参操作，字典、元组等**，**为后面大型项目做铺垫**，**可能现在的项目单个进程和多个进程还没有很好的体现，但是后面随着项目规模的变大，你会很好的发现单进程和多进程的区别。所以了解进程十分重要**

**`元组传参`**，

import os     #  一般用于文件处理
    
    
    import multiprocessing    # 进程包
    import time
    # 1.work1
    def work(count,number):
        print("当前work：",os.getpid())
        #  TODO  当前的进程名
        print("work:",multiprocessing.current_process())
    
        #  TODO  获取父进程
        print("work的父进程是：",os.getppid())
        for i in range(5):
            print("work正在工作中.....")
            time.sleep(0.2)
    ## 2.work2
    # def work2(count,number):
    #     for i in range(5):
    #         #  TODO  当前的进程名
    #         print("work2:", multiprocessing.current_process())
    #         #  TODO  获取父进程
    #         print("work2的父进程是：", os.getppid())
    #         print("当前work2：", os.getpid())
    #         print("work2正在工作中......")
    #         time.sleep(0.2)
    
    if __name__=="__main__":    #  TODO  主进程
        print("main：",os.getpid())
        # TODO 两个子进程
        work_process=multiprocessing.Process(target=work,args=(5,10))
        # work2_process=multiprocessing.Process(target=work2,kwargs={"count":5,"number":10})
        #   启动子进程任务
        work_process.start()
        # work2_process.start()
    
    
    multiprocessing.Process()

**`运行结果：`**

main： 11896
    当前work： 23728
    work: <Process name='Process-1' parent=11896 started>
    work的父进程是： 11896
    work正在工作中.....
    work正在工作中.....
    work正在工作中.....
    work正在工作中.....
    work正在工作中.....

**元组传参就是主进程将数据以元组的方式传递给子进程，类似于python中调用一个函数，通过元组的方式传参。不太理解的可以去了解一下Python的传参过程，很重要，想要掌握python就必须要掌握它。**  
**`元组格式`** **（1，5，3）、（“小红”,“小花”,“18”）、（2,）**  
**`注意：一个元素是要加一个逗号`**  
**python中的元素交换**  
**`a,b=b,a`**  
**这样就可以交换a,b的值**

--------------------

**`字典传参`**

import os     #  一般用于文件处理
    
    
    import multiprocessing    # 进程包
    import time
    # 1.work1
    # def work(count,number):
    #     print("当前work：",os.getpid())
    #     #  TODO  当前的进程名
    #     print("work:",multiprocessing.current_process())
    #
    #     #  TODO  获取父进程
    #     print("work的父进程是：",os.getppid())
    #     for i in range(5):
    #         print("work正在工作中.....")
    #         time.sleep(0.2)
    # 2.work2
    def work2(count,number):
        for i in range(5):
            #  TODO  当前的进程名
            print("work2:", multiprocessing.current_process())
            #  TODO  获取父进程
            print("work2的父进程是：", os.getppid())
            print("当前work2：", os.getpid())
            print("work2正在工作中......")
            time.sleep(0.2)
    
    if __name__=="__main__":    #  TODO  主进程
        print("main：",os.getpid())
        # TODO 两个子进程
        # work_process=multiprocessing.Process(target=work,args=(5,10))
        work2_process=multiprocessing.Process(target=work2,kwargs={
        "count":5,"number":10})
        #   启动子进程任务
        # work_process.start()
        work2_process.start()

time.sleep(0.2) 休息0.2s,如果不休息0.2s你会发现太顺畅，结果一下子就出来了，休息0.2s可以更好地看清楚进程运行  
**`运行结果：`**

main： 18372
    work2: <Process name='Process-1' parent=18372 started>
    work2的父进程是： 18372
    当前work2： 13016
    work2正在工作中......
    work2: <Process name='Process-1' parent=18372 started>
    work2的父进程是： 18372
    当前work2： 13016
    work2正在工作中......
    work2: <Process name='Process-1' parent=18372 started>
    work2的父进程是： 18372
    当前work2： 13016
    work2正在工作中......
    work2: <Process name='Process-1' parent=18372 started>
    work2的父进程是： 18372
    当前work2： 13016
    work2正在工作中......
    work2: <Process name='Process-1' parent=18372 started>
    work2的父进程是： 18372
    当前work2： 13016
    work2正在工作中......
    
    Process finished with exit code 0

**字典传参就是主进程将数据以字典的方式传递给子进程，类似于python中调用一个函数，通过字典的方式传参。不太理解的可以去了解一下Python的传参过程，很重要，想要掌握python就必须要掌握它。** \*\*字典和元组都是python常见的两种格式，其中字典是以键对值存在的，就是一把药匙一个门，键就是药匙，值就是门，可能一把药匙可以开n个门，但是一个门不可能同时存在多个药匙。也就是说，`键不可以重复，是唯一的，但是值可以重复`。所以通常可以通过键去提取值。\*\*上文提点传参就是将数据以字典的形式传出去。

**只要是进程你反复运行结果都是不一样的，因为进程是系统随机分配的，基本上不可能重复，如果你反复运行是重复的，恭喜你，你可以买彩票了，别忘了叫上我。**

**`注意：`**  
**守护主进程**

deamo = True

**子进程销毁**

terminate

**退出进程**

exit()

**`常用属性`**  
**name:当前进程起别名,默认为Process-1，依次递增**  
**实例方法：**

start()

**启动子进程实例(创建子进程)**

join()

**等待子进程执行结束**

terminate()

**`不管任务是否执行完毕，立即终止子进程.`**  
希望这篇文章对大家有所帮助

[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5LiN6Imv5L2_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/0c67c4d03215406b86349e822a611da5.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5LiN6Imv5L2_,size_20,color_FFFFFF,t_70,g_se,x_16