进程的应用

目录

• 什么是进程
• 进程与程序的区别？
• 进程之multiprocessing模块
• Process
• 创建进程的两种方式
  • 创建进程的第一种方式：
  • 创建进程的第二种方式：
• 进程之join方法
  • 串行：
  • 并行：
  • join方法：

什么是进程

进程：正在进行的一个过程或者说一个任务，每个进程在内存中使用的数据彼此是物理级别的隔离

举例（单核+多道，实现多个进程的并发执行）：

我在一个时间段内有许多需要做的事情，比如烧饭，烧水，洗衣服，但是我一次只能做一件事情。但是如果我每个事情做了以后，暂停一下又去做其他的事情，这不就保证了我所有的事情都在进行中嘛

进程与程序的区别？

区别：正在进行的一个过程或者说一个任务,而程序仅仅仅只是一堆代码。

进程之multiprocessing模块

特点：

• multiprocessing模块的功能众多：支持子进程、通信和共享数据、执行不同形式的同步，提供了Process、Queue、Pipe、Lock等组件。
• 需要再次强调的一点是：与线程不同，进程没有任何共享状态，进程修改的数据，改动仅限于该进程内。

Process

****** 参数介绍******

group参数未使用，值始终为None

target表示调用对象，即子进程要执行的任务

args表示调用对象的位置参数元组，args=(1,2,'egon',)

kwargs表示调用对象的字典,kwargs={'name':'egon','age':18}

name为子进程的名称

方法介绍

p.start()：启动进程，并调用该子进程中的p.run() 
p.run():进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法  
p.terminate():强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁
p.is_alive():如果p仍然运行，返回True

p.join([timeout]):主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。timeout是可选的超时时间，需要强调的是，p.join只能join住start开启的进程，而不能join住run开启的进程  

创建进程的两种方式

创建进程的第一种方式：

###开启子进程方式一
#导入模块
from multiprocessing import Process

import time

#写进程
def zi():
    print('进程开启')
    time.sleep(3)
    print('进程结束')

#win 10下必须写
if __name__ == '__main__':
    #创建进程
    p = Process(target= zi)
    #启动进程
    p.start()

创建进程的第二种方式：

###开启进程方式二
#导包

from multiprocessing import Process

import time


#通过自定义类的方式启动进程
#继承Process
class My(Process):
    def __init__(self):
        super().__init__()

    def run(self):
        print('进程启动-----')
        time.sleep(3)
        print('进程结束-----')


if __name__ == '__main__':
    p = My()
    p.start()

进程之join方法

串行：

• 同一时间段里面，程序依次按顺序执行

并行：

• 同一时间段里面，程序同时执行

join方法：

方法一：

from multiprocessing import Process
import time

def dask():
    print('进程开启——————————')
    time.sleep(5)
    print('进程结束——————————')

if __name__ == '__main__':
    p = Process(target= dask)
    p.start()
    p.join()
    print('主进程')

进程开启——————————
​ 进程结束——————————
​ 主进程

from multiprocessing import Process
import time

def dask():
    print('进程开启——————————')
    time.sleep(5)
    print('进程结束——————————')

if __name__ == '__main__':
    p = Process(target= dask)
    p.start()
    #p.join()
    print('主进程')

主进程
​ 进程开启——————————
​ 进程结束——————————

方法二

from multiprocessing import Process
import time
def foo(x):
    print(f'----进程{x}开始----')
    time.sleep(x)
    print(f'----进程{x}结束----')


if __name__ == '__main__':
    start = time.time()
    p_list = []
    for i in range(1,4):
        p = Process(target= foo, args=(i,))
        p.start()
        p_list.append(p)
    for p in p_list:
        p.join()
    end = time.time()
    print(end-start)
    print('主')

​ ----进程2开始----
​ ----进程3开始----
​ ----进程1开始----
​ ----进程1结束----
​ ----进程2结束----
​ ----进程3结束----
​ 3.1455421447753906
​ 主

查看进程的pid号

什么是pid号

当主进程运行时，会等待子进程全部运行完毕，用于回收已经释放掉的资源。通过pid号来识别。

def task():

    print('子进程开始')
    print('查看子进程自己的pid',current_process().pid)



if __name__ == '__main__':
    p = Process(target= task)
    p.start()
    print('主进程中查看自己的pid',p.pid)
 ###########

''' # 记住这些就ok了 这个是要掌握的
	# 角度 站在当前进程的角度os.getpid（）
	#获取当前进程的pidos.getppid() 
	#获取当前进程的父进程的pid子进程对象.pid 
	#获取当前进程的子进程pid'''

守护进程

会随着主进程的结束而结束。

主进程创建守护进程

　　其一：守护进程会在主进程代码执行结束后就终止

　　其二：守护进程内无法再开启子进程,否则抛出异常

from multiprocessing import Process
import time
def foo():
    print('守护进程开启')
    time.sleep(4)
    print('守护进程结束')
    
    
if __name__ == '__main__':
    p = Process(target= foo)
    p.daemon = True
    p.start()
    time.sleep(2)
    print('主')