Python并发编程 —— 在Python程序中的进程操作

运行中的程序就是一个进程。所有的进程都是通过它的父进程来创建的。因此，运行起来的python程序也是一个进程，那么我们也可以在程序中再创建进程。多个进程可以实现并发效果，也就是说，当我们的程序中存在多个进程的时候，在某些时候，就会让程序的执行速度变快。我们可以借助python中强大的模块。来实现创建进程这个功能。

1、multiprocessing模块

把所有和进程相关的机制都封装在multiprocessing模块中了（内置模块）。

仔细说来，multiprocess不是一个模块而是python中一个操作、管理进程的包。之所以叫multi是取自multiple的多功能的意思,在这个包中几乎包含了和进程有关的所有子模块。大致可以分为四个部分：创建进程部分，进程同步部分，进程池部分，进程之间数据共享。

2、Process模块

(1)、Process模块介绍

process模块是一个创建进程的模块，借助这个模块，就可以完成进程的创建。

参数介绍：

Process([group [, target [, name [, args [, kwargs]]]]])，由该类实例化得到的对象，表示一个子进程中的任务（尚未启动）

# 强调：
1. 需要使用关键字的方式来指定参数
2. args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号

参数介绍：
1.group 参数未使用，值始终为None
2.target 表示调用对象，即子进程要执行的任务
3.args 表示调用对象的位置参数元组，args=(1,2,'a',)
4.kwargs 表示调用对象的字典,kwargs={'name':'cai','age':20}
5.name 为子进程的名称

方法介绍：

1、p.start()：启动进程，并调用该子进程中的p.run() 
2、p.run(): 进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法  
3、p.terminate(): 强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁
4、p.is_alive(): 如果p仍然运行，返回True
5、p.join([timeout]): 主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。timeout是可选的超时时间，需要强调的是，p.join只能join住start开启的进程，而不能join住run开启的进程

属性介绍：

1、p.daemon：默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置
2、p.name: 进程的名称
3、p.pid： 进程的pid
4、p.exitcode: 进程在运行时为None、如果为–N，表示被信号N结束(了解即可)
5、p.authkey: 进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功（了解即可）

在Windows中使用process模块的注意事项：

在Windows操作系统中由于没有fork（Linux操作系统中创建进程的机制），在创建进程的时候会自动 import 启动它的这个文件，而在 import 的时候又执行了整个文件，因此如果将process()直接写在文件中就会无限递归创建子进程报错，所以必须把创建子进程的部分使用 if  __name__  == '__main__'判断保护起来，就不会递归运行了。

(2)、使用process模块创建进程

# 创建进程，并查看主进程和子进程的进程号
import os
import time
from multiprocessing import Process

def func():
    '''
    在子进程中执行的func
    :return:
    '''
    print('子进程 :',os.getpid(),os.getppid())
    time.sleep(3)
    
if __name__ == '__main__':
    p = Process(target=func)
    p.start()       # start相当于告诉操作系统要开启一个子进程,而子进程的调度是由操作系统控制的
    print('主进程 :',os.getpid())    
 
# 执行结果：先打印主进程id  再打印子进程id  （异步）
# 主进程是在子进程执行完毕之后才结束的，主进程回收子进程的资源

(3)、join 方法：阻塞，直到对应的子进程对象执行结束

import time
from multiprocessing import Process

def son_process():
    time.sleep(4)
    print('通知xxx用户,机器挂掉了')

if __name__ == '__main__':
    p = Process(target=son_process)
    p.start()
    p.join()                # 阻塞,直到p对应的子进程对象执行结束
    print('所有任务结束')

import time
from multiprocessing import Process

def son_process(n):
    print('start', n)
    time.sleep(2)
    print('end',n)

if __name__ == '__main__':
    p_l = []
    for i in range(10):
        p = Process(target=son_process,args=(i,))
        p.start()   # start相当于告诉操作系统要开启一个子进程,而子进程的调度是由操作系统控制的
        p_l.append(p)
    for p in p_l:p.join()  # join 如果执行这句话的时候子进程已经结束了,那么join就不阻塞了
    print('所有任务结束')

(4)、多个子进程

import os
import time
from multiprocessing import Process

def son_process():
    print('strat son',os.getpid())
    time.sleep(1)
    print('end son')

if __name__ == '__main__':
    print(os.getpid())
    for i in range(5):
        Process(target=son_process).start()
    
# 多个子进程同时运行时，子进程的执行顺序不是根据启动顺序决定的

(5)、守护进程

守护进程会随着父进程的代码结束而结束

主进程创建守护进程

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

　　二：守护进程内无法再开启子进程,否则抛出异常：AssertionError: daemonic processes are not allowed to have children

注意：进程之间是互相独立的，主进程代码运行结束，守护进程随即终止

import time
from multiprocessing import Process

def son():
    while True:
        time.sleep(1)
        print('in son')


if __name__ == '__main__':
    p = Process(target=son)
    p.daemon = True              # 将当前的子进程设置为守护进程
    # 一定要在p.start()前设置,设置p为守护进程,禁止p创建子进程,并且父进程代码执行结束,p即终止运行
    p.start()
    time.sleep(5)

正常情况下，父进程永远会等着子进程结束，子进程结束之后，父进程才会结束
如果设置了守护进程，父进程的代码结束之后，守护进程也跟着结束

# 注：
代码结束和进程结束是两回事

# 没设置守护进程时：
子进程的代码和主进程的代码自己执行自己的，相互之间没关系
如果主进程的代码先结束，主进程不结束，等子进程代码结束，回收子进程的资源，主进程才结束
如果子进程的代码先结束，主进程边回收子进程的资源边执行自己的代码，当代码和资源都回收结束，主进程才结束

# 设置了守护进程
子进程的代码和主进程的代码自己执行自己的，互相之间没关系
一旦主进程的代码先结束，主进程会先结束掉子进程，然后回收资源，然后主进程才结束

守护进程不会守护除了主进程代码之外的其他子进程

import time
from multiprocessing import Process

def son():
    while True:
        time.sleep(1)
        print('in son')

def son2():
    print('start son2')
    time.sleep(10)
    print('end son2')

if __name__ == '__main__':
    p = Process(target=son)
    p.daemon = True
    p.start()
    Process(target=son2).start()
    time.sleep(5)

如果偏要求守护进程在子进程结束之后才结束

import time
from multiprocessing import Process

def son():
    while True:
        time.sleep(1)
        print('in son')

def son2():
    print('start son2')
    time.sleep(10)
    print('end son2')

if __name__ == '__main__':
    p = Process(target=son)
    p.daemon = True
    p.start()
    p = Process(target=son2)
    p.start()
    time.sleep(5)
    p.join()          # 所有的子进程都执行完，才不会阻塞

(6)、Process对象中的其他方法

import time
from multiprocessing import Process

def son():
    while True:
        time.sleep(1)
        print('in son')

if __name__ == '__main__':
    p = Process(target=son)
    p.start()
    time.sleep(5)
    print(p.is_alive())
    p.terminate()           # 异步非阻塞操作    # 强制终止进程p
    # 关闭进程,不会立即关闭,所以is_alive 立刻 查看的结果可能还是存活
    time.sleep(0.1)
    print(p.is_alive())     # 判断子进程是否存活
    print('主进程的代码并不结束')

(7)、面向对象的方式开启子进程：（继承Process类的形式开启进程的方式）

import os
from multiprocessing import Process

class MyProcess(Process):
    def run(self):
        print(os.getpid())

if __name__ == '__main__':
    print('主 :',os.getpid())
    MyProcess().start()         # start会自动调用run

(8)、传参数

import os
from multiprocessing import Process

class MyProcess(Process):
    def __init__(self,name):    # 执行父类的init
        super().__init__()
        self.name=name
    def run(self):
        print(os.getpid())
        print('%s 在工作' %self.name)

if __name__ == '__main__':
    print('主 :',os.getpid())
    MyProcess('yong').start()   
    MyProcess('liang').start()

(9)、判断进程之间的数据是否隔离

from multiprocessing import Process

n = 0
def son():
    global n
    n += 1

if __name__ == '__main__':
    p_l = []
    for i in range(20):
        p = Process(target=son)
        p.start()
        p_l.append(p)
    for p in p_l:p.join()
    print(n)

3、数据安全(锁)：用来保证数据安全

如果多个进程同时对一个文件进行操作会出现什么问题？

实现了程序的异步，让多个任务可以同时在几个进程中并发处理，但它们之间的运行没有顺序，一旦开启也不受我们控制。尽管并发编程让我们能更加充分的利用IO资源，但是也给我们带来了新的问题：当多个进程使用同一份数据资源的时候，就会引发数据安全或顺序混乱问题。

# 多进程抢占输出资源
import os
import time
import random
from multiprocessing import Process

def work(n):
    print('%s: %s is running' %(n,os.getpid()))
    time.sleep(random.random())
    print('%s:%s is done' %(n,os.getpid()))

if __name__ == '__main__':
    for i in range(3):
        p=Process(target=work,args=(i,))
        p.start()

# 使用锁维护执行顺序
# 由并发变成了串行,牺牲了运行效率,但避免了竞争
import os
import time
import random
from multiprocessing import Process, Lock

def work(lock,n):
    lock.acquire()       # 给这段代码上锁
    print('%s: %s is running' % (n, os.getpid()))
    time.sleep(random.random())
    print('%s: %s is done' % (n, os.getpid()))
    lock.release()       # 给这段代码解锁
if __name__ == '__main__':
    lock=Lock()
    for i in range(3):
        p=Process(target=work,args=(lock,i))
        p.start()

# 上面这种情况虽然使用加锁的形式实现了顺序的执行，但是程序又重新变成串行了，这样确实会浪费了时间，却保证了数据的安全。
# 在使用进程锁时同时要注意死锁问题(多次引用互斥锁Lock)，可以使用递归锁(RLock)

from multiprocessing import Process,Lock

def change(lock):
    print('一部分并发的代码,多个进程之间互相不干扰的执行着')
    lock.acquire()                       # 给这段代码上锁
    with open('file','r') as f:
        content = f.read()
    num = int(content)
    num += 1
    for i in range(1000000):i+=1
    with open('file','w') as f:
        f.write(str(num))
    lock.release()                       # 给这段代码解锁
    print('另一部分并发的代码,多个进程之间互相不干扰的执行着')

if __name__ == '__main__':
    lock = Lock()
    for i in range(10):
        Process(target=change,args=(lock,)).start()

当多个进程同时操作文件 / 共享一些数据的时候就会出现数据不安全（读数据：可以同时读，写数据：不能同时写）

当开启多个进程，同时执行10000000行代码，其中有20行代码涉及到了操作同一个文件，只给这20行代码枷锁，来保证数据的安全。

# 加锁可以保证多个进程修改同一块数据时，同一时间只能有一个任务可以进行修改，即串行的修改，没错，速度是慢了，但牺牲了速度却保证了数据安全。

# 虽然可以用文件共享数据实现进程间通信，但问题是：
	1.效率低（共享数据基于文件，而文件是硬盘上的数据）
	2.需要自己加锁处理

# 因此我们最好找寻一种解决方案能够兼顾：1、效率高（多个进程共享一块内存的数据）2、帮我们处理好锁问题。这就是mutiprocessing模块为我们提供的基于消息的IPC通信机制：队列和管道。
队列和管道都是将数据存放于内存中
队列又是基于（管道+锁）实现的，可以让我们从复杂的锁问题中解脱出来，
我们应该尽量避免使用共享数据，尽可能使用消息传递和队列，避免处理复杂的同步和锁问题，而且在进程数目增多时，往往可以获得更好的可获展性。

4、进程之间的数据共享(进程之间通信)

(1)、进程之间通信 —— IPC (Inter Process Communication)

内置的模块实现的机制：队列 \ 管道

第三方工具： redis rabbitMQ memcache

(2)、队列

创建共享的进程队列，Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递。

Queue([maxsize]) 
创建共享的进程队列。
参数 ：maxsize是队列中允许的最大项数。如果省略此参数，则无大小限制。
底层队列使用管道和锁定实现。

# 队列Queue  = 管道Pipe  +  锁
# Pipe 基于文件实现的(socket + pickle)   =  数据不安全
# Queue 基于文件(socket + pickle) +  锁(lock) 实现的  = 数据安全

# 在进程之间维护数据的安全 --- 进程安全
# 队列是进程安全的（进程队列保证了进程的数据安全）
# 队列都是先进先出的

队列中的方法介绍

Queue([maxsize]) 
创建共享的进程队列。maxsize是队列中允许的最大项数。如果省略此参数，则无大小限制。底层队列使用管道和锁定实现。另外，还需要运行支持线程以便队列中的数据传输到底层管道中。 

Queue的实例q具有以下方法：
q.get( [ block [ ,timeout ] ] ) 
返回q中的一个项目。如果q为空，此方法将阻塞，直到队列中有项目可用为止。block用于控制阻塞行为，默认为True. 如果设置为False，将引发Queue.Empty异常（定义在Queue模块中）。timeout是可选超时时间，用在阻塞模式中。如果在制定的时间间隔内没有项目变为可用，将引发Queue.Empty异常。

q.get_nowait( ) 
同q.get(False)方法。

q.put(item [, block [,timeout ] ] ) 
将item放入队列。如果队列已满，此方法将阻塞至有空间可用为止。block控制阻塞行为，默认为True。如果设置为False，将引发Queue.Empty异常（定义在Queue库模块中）。timeout指定在阻塞模式中等待可用空间的时间长短。超时后将引发Queue.Full异常。

q.qsize() 
返回队列中目前项目的正确数量。此函数的结果并不可靠，因为在返回结果和在稍后程序中使用结果之间，队列中可能添加或删除了项目。在某些系统上，此方法可能引发NotImplementedError异常。

q.empty() 
如果调用此方法时 q为空，返回True。如果其他进程或线程正在往队列中添加项目，结果是不可靠的。也就是说，在返回和使用结果之间，队列中可能已经加入新的项目。

q.full() 
如果q已满，返回为True. 由于线程的存在，结果也可能是不可靠的（参考q.empty（）方法）。。

q.close() 
关闭队列，防止队列中加入更多数据。调用此方法时，后台线程将继续写入那些已入队列但尚未写入的数据，但将在此方法完成时马上关闭。如果q被垃圾收集，将自动调用此方法。关闭队列不会在队列使用者中生成任何类型的数据结束信号或异常。例如，如果某个使用者正被阻塞在get()操作上，关闭生产者中的队列不会导致get()方法返回错误。

q.cancel_join_thread() 
不会再进程退出时自动连接后台线程。这可以防止join_thread()方法阻塞。

q.join_thread() 
连接队列的后台线程。此方法用于在调用q.close()方法后，等待所有队列项被消耗。默认情况下，此方法由不是q的原始创建者的所有进程调用。调用q.cancel_join_thread()方法可以禁止这种行为。

代码示例

'''
multiprocessing模块支持进程间通信的两种主要形式:管道和队列，都是基于消息传递实现的
'''

from multiprocessing import Queue
q=Queue(3)

# put ,get ,put_nowait,get_nowait,full,empty
q.put(3)
q.put(3)
q.put(3)
# q.put(3)   # 如果队列已经满了，程序就会停在这里，等待数据被别人取走，再将数据放入队列。
           # 如果队列中的数据一直不被取走，程序就会永远停在这里。
    	  # put是一个同步阻塞方法,会阻塞直到队列不满
try:
    q.put_nowait(3)   # 可以使用put_nowait，如果队列满了不会阻塞，但是会因为队列满了而报错。
    				# put_nowait 同步非阻塞方法
except: # 因此我们可以用一个try语句来处理这个错误。这样程序不会一直阻塞下去，但是会丢掉这个消息。
    print('队列已经满了')

# 因此，我们再放入数据之前，可以先看一下队列的状态，如果已经满了，就不继续put了。
print(q.full())   # 满了  # 查看当前队列是否已满

print(q.get())
print(q.get())
print(q.get())
# print(q.get())     # 同put方法一样，如果队列已经空了，那么继续取就会出现阻塞。
				   # get是一个同步阻塞方法,会阻塞直到数据来
try:
    q.get_nowait(3)  # 可以使用get_nowait，如果队列满了不会阻塞，但是会因为没取到值而报错。
except:  # 因此我们可以用一个try语句来处理这个错误。这样程序不会一直阻塞下去。
    print('队列已经空了')

print(q.empty())  # 空了  # 查看当前队列是否已空
ret = q.qsize()  # 查看当前队列有多少值

父进程发送数据给子进程

from multiprocessing import Queue,Process

def son(q):
    print(q.get())    # 调用主函数中p进程传递过来的进程参数

if __name__ == '__main__':
    q = Queue()       # 创建一个Queue对象 
    p = Process(target=son,args=(q,)) # 创建一个进程
    p.start()
    q.put(123)    # put函数为向队列中添加一条数据

# 上面是一个queue的简单应用，使用队列q对象调用get函数来取得队列中的数据。

批量生产数据放入队列再批量获取结果

import os
import time
import multiprocessing

# 向queue中输入数据的函数
def inputQ(queue):
    info = str(os.getpid()) + '(put):' + str(time.asctime())
    queue.put(info)

# 向queue中输出数据的函数
def outputQ(queue):
    info = queue.get()
    print ('%s%s\033[32m%s\033[0m'%(str(os.getpid()), '(get):',info))

# Main
if __name__ == '__main__':
    multiprocessing.freeze_support()
    record1 = []   # store input processes
    record2 = []   # store output processes
    queue = multiprocessing.Queue(3)

    # 输入进程
    for i in range(10):
        process = multiprocessing.Process(target=inputQ,args=(queue,))
        process.start()
        record1.append(process)

    # 输出进程
    for i in range(10):
        process = multiprocessing.Process(target=outputQ,args=(queue,))
        process.start()
        record2.append(process)

    for p in record1:
        p.join()

    for p in record2:
        p.join()

5、进程池和 multiprocess.Pool 模块

(1)、进程池

# 为什么要有进程池?
在程序实际处理问题过程中，忙时会有成千上万的任务需要被执行，闲时可能只有零星任务。那么在成千上万个任务需要被执行的时候，我们就需要去创建成千上万个进程吗？首先，创建进程需要消耗时间，销毁进程也需要消耗时间。第二即便开启了成千上万的进程，操作系统也不能让他们同时执行，这样反而会影响程序的效率。因此我们不能无限制的根据任务开启或者结束进程。因此引入了进程池。

# 进程池的概念
定义一个池子，在里面放上固定数量的进程，有需求来了，就拿一个池中的进程来处理任务，等到处理完毕，进程并不关闭，而是将进程再放回进程池中继续等待任务。如果有很多任务需要执行，池中的进程数量不够，任务就要等待之前的进程执行任务完毕归来，拿到空闲进程才能继续执行。也就是说，池中进程的数量是固定的，那么同一时间最多有固定数量的进程在运行。这样不会增加操作系统的调度难度，还节省了开闭进程的时间，也一定程度上能够实现并发效果。

(2)、multiprocess.Pool模块

Pool([numprocess  [,initializer [, initargs]]]):     创建进程池

1、numprocess: 要创建的进程数，如果省略，将默认使用cpu_count()的值
2、initializer：是每个工作进程启动时要执行的可调用对象，默认为None
3、initargs：是要传给initializer的参数组

方法介绍：

p.apply(func [, args [, kwargs]]): 在一个池工作进程中执行func(*args,**kwargs),然后返回结果。
'''需要强调的是：此操作并不会在所有池工作进程中并执行func函数。如果要通过不同参数并发地执行func函数，必须从不同线程调用p.apply()函数或者使用p.apply_async()'''

p.apply_async(func [, args [, kwargs]]): 在一个池工作进程中执行func(*args,**kwargs),然后返回结果。
'''此方法的结果是AsyncResult类的实例，callback是可调用对象，接收输入参数。当func的结果变为可用时，将理解传递给callback。callback禁止执行任何阻塞操作，否则将接收其他异步操作中的结果。'''
   
p.close(): 关闭进程池，防止进一步操作。如果所有操作持续挂起，它们将在工作进程终止前完成

P.jion(): 等待所有工作进程退出。此方法只能在close()或teminate()之后调用

# 其他方法：方法apply_async()和map_async（）的返回值是AsyncResul的实例obj。实例具有以下方法
obj.get():返回结果，如果有必要则等待结果到达。timeout是可选的。如果在指定时间内还没有到达，将引发异常。如果远程操作中引发了异常，它将在调用此方法时再次被引发。
obj.ready():如果调用完成，返回True
obj.successful():如果调用完成且没有引发异常，返回True，如果在结果就绪之前调用此方法，引发异常
obj.wait([timeout]):等待结果变为可用。
obj.terminate()：立即终止所有工作进程，同时不执行任何清理或结束任何挂起工作。如果p被垃圾回收，将自动调用此函数

代码示例：

# 进程池的同步调用
import os,time
from multiprocessing import Pool

def work(n):
    print('%s run' %os.getpid())
    time.sleep(3)
    return n**2

if __name__ == '__main__':
    p=Pool(3)                       # 进程池中从无到有创建三个进程,以后一直是这三个进程在执行任务
    res_l=[]
    for i in range(10):
        res=p.apply(work,args=(i,)) # 同步调用，直到本次任务执行完毕拿到res，等待任务work执行的过程中可能有阻塞也可能没有阻塞
                                    # 但不管该任务是否存在阻塞，同步调用都会在原地等着
    print(res_l)

# 进程池的异步调用
import os
import time
import random
from multiprocessing import Pool

def work(n):
    print('%s run' %os.getpid())
    time.sleep(random.random())
    return n**2

if __name__ == '__main__':
    p=Pool(3)                            # 进程池中从无到有创建三个进程,以后一直是这三个进程在执行任务
    res_l=[]
    for i in range(10):
        res=p.apply_async(work,args=(i,)) # 异步运行，根据进程池中有的进程数，每次最多3个子进程在异步执行
                                          # 返回结果之后，将结果放入列表，归还进程，之后再执行新的任务
                                          # 需要注意的是，进程池中的三个进程不会同时开启或者同时结束
                                          # 而是执行完一个就释放一个进程，这个进程就去接收新的任务。  
        res_l.append(res)

    # 异步apply_async用法：如果使用异步提交的任务，主进程需要使用jion，等待进程池内任务都处理完，然后可以用get收集结果
    # 否则，主进程结束，进程池可能还没来得及执行，也就跟着一起结束了
    p.close()
    p.join()
    for res in res_l:
        print(res.get()) # 使用get来获取apply_aync的结果,如果是apply,则没有get方法,因为apply是同步执行,立刻获取结果,也根本无需get

6、使用 ProcessPoolExecutor 实现进程池

import time
from concurrent.futures import ProcessPoolExecutor

def task(n1, n2):
    time.sleep(2)
    print('任务')

if __name__ == '__main__':      
    # 创建进程池
    pool = ProcessPoolExecutor(10)
    for i in range(20):
        pool.submit(task, i, 1)
    print('END')

posted @ 2020-11-25 13:38 永亮阅读(392) 评论(0) 编辑收藏举报

刷新页面返回顶部

YongLiangのBOKE

———————————————— 我曾十步一回头@CYL

Python并发编程 —— 在Python程序中的进程操作

1、multiprocessing模块

2、Process模块

(1)、Process模块介绍

(2)、使用process模块创建进程

(3)、join 方法：阻塞，直到对应的子进程对象执行结束

(4)、多个子进程

(5)、守护进程

(6)、Process对象中的其他方法

(7)、面向对象的方式开启子进程：（继承Process类的形式开启进程的方式）

(8)、传参数

(9)、判断进程之间的数据是否隔离

3、数据安全(锁)：用来保证数据安全

4、进程之间的数据共享(进程之间通信)

(1)、进程之间通信 —— IPC (Inter Process Communication)

(2)、队列

5、进程池和 multiprocess.Pool 模块

(1)、进程池

(2)、multiprocess.Pool模块

6、使用 ProcessPoolExecutor 实现进程池

公告

YongLiangのBOKE

———————————————— 我曾十步一回头@CYL

Python并发编程 —— 在Python程序中的进程操作

1、multiprocessing模块

2、Process模块

(1)、Process模块介绍

(2)、使用process模块创建进程

(3)、join 方法： 阻塞，直到对应的子进程对象执行结束

(4)、多个子进程

(5)、守护进程

(6)、Process对象中的其他方法

(7)、面向对象的方式开启子进程：（继承Process类的形式开启进程的方式）

(8)、传参数

(9)、判断进程之间的数据是否隔离

3、数据安全(锁)：用来保证数据安全

4、进程之间的数据共享(进程之间通信)

(1)、进程之间通信 —— IPC (Inter Process Communication)

(2)、队列

5、进程池和 multiprocess.Pool 模块

(1)、进程池

(2)、multiprocess.Pool模块

6、使用 ProcessPoolExecutor 实现进程池

公告

(3)、join 方法：阻塞，直到对应的子进程对象执行结束