什么是进程？
程序不能单独执行，只有将程序装载到内存中，系统为它分配资源才能运行，而这种执行的过程就叫做进程。进程是操作系统调度的最小单位。
程序和进程的区别在于：程序是储存在硬盘上指令的有序集合，是静态的；进程是内存中程序的一次执行过程，属于动态概念。
线程和进程的区别：
进程是资源的集合，进程要在CPU执行，必须要创建线程，至少要有一个线程在运行。
1.线程共享创建它的进程的地址空间。进程的内存空间是独立的。
2.线程可以直接访问其进程的数据段（不同线程共享同一个进程的数据），进程间不共享。
3.线程可以与其他线程进行通信，进程必须使用进程间通信（中间代理）与同级进程进行通信。
4.新的线程很容易创建，新的进程需要父进克隆。
5.线程可以直接操作和控制同一进程内的其它线程，而进程只能操作子进程。
6.对主线程的修改可能会影响到其它线程的行为。对父进程的修改不会影响子进程（不删除父进程的前提下）。
Python多进程的使用
Process 类用来描述一个进程对象。创建子进程的时候，只需要传入一个执行函数和函数的参数即可完成 Process 示例的创建。
star() 方法启动进程。
join() 方法实现进程间的同步，等待所有进程退出。
close() 用来阻止多余的进程涌入进程池 Pool 造成进程阻塞。
multiprocessing.Process(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)
target 是函数名字，需要调用的函数
args 函数需要的参数，以 元组 的形式传入
multiprocessing模块的使用跟线程类似
![]()
![]()
import multiprocessing
import threading
import time
def t_run():
print("线程号",threading.get_ident()) # 线程id
def run(name):
time.sleep(1)
print('hello', name)
t = threading.Thread(target=t_run)
t.start()
if __name__ == '__main__':
for i in range(10):
p = multiprocessing.Process(target=run, args=(i,))
p.start()
multiprocessing
所有的进程都是由父进程启动的，所以发现此程序的父进程ID正是PyCharm。
每个进程都是相互独立的，存在于不同的内存地址。
进程间通信
- 首先声明一点，这里所说的进程间通信指的是父子进程之间的通信机制。如果两个进程间没有关系，这里的机制是无法奏效的。
- 通信方式有：进程队列Queue、管道通信Pipe、共享数据Manger
1.进程队列Queue
进程队列直接使用multiprocessing模块的Queue类，不同于线程队列的queue模块。
![]()
![]()
import multiprocessing
def f(q):
q.put([42, None, 'hello'])
q.put(30)
if __name__ == '__main__':
q = multiprocessing.Queue()
p = multiprocessing.Process(target=f, args=(q,)) # 将队列copy一份传给子进程
p.start()
print(q.get()) # 在父进程中取出队列中数据
print(type(q.get()))
p.join()
进程队列
2.管道Pipe
两个进程在管道两边收发数据。
![]()
![]()
import multiprocessing
'''Pipe管道实例，两个进程在管道两边收发数据'''
def f(conn):
conn.send([42, None, 'hello']) # 发送数据
print("child_conn接收:",conn.recv()) # 接收数据
conn.close()
def s(conn):
conn.send("你好，紫禁城") # 发送数据
print("parent_conn接收:",conn.recv()) # 接收数据
conn.close()
if __name__ == '__main__':
parent_conn, child_conn = multiprocessing.Pipe() # 管道实例，连接着两个进程
p = multiprocessing.Process(target=f, args=(child_conn,))
p2 = multiprocessing.Process(target=s,args=(parent_conn,))
p.start()
p2.start()
#print(parent_conn.recv()) # 父进程接收管道的数据
#parent_conn.send("你好，紫禁城") # 父进程发送数据
p.join()
p2.join()
Pipe
3.进程间共享数据Manger
使用Manger()可以创建共享的数据，包括列表，字典，元组等多种类型。
![]()
![]()
from multiprocessing import Process, Manager
def f(d, l):
d[1] = '1'
d['2'] = 2
d[0.25] = None
l.append(1)
print(l)
if __name__ == '__main__':
with Manager() as manager:
d = manager.dict()
l = manager.list(range(5))
p_list = []
for i in range(10):
p = Process(target=f, args=(d, l))
p.start()
p_list.append(p)
for res in p_list:
res.join()
print(d)
print(l)
Manger
Lock
屏幕锁，防止一个进程未打印完毕，另一个进程插入
![]()
![]()
def f(l,i):
l.acquire()
print("hello",i)
l.release()
if __name__ == '__main__':
l=Lock()
for i in range(10):
Process(target=f,args=(l,i)).start()
lock
进程池
在利用Python进行系统管理的时候，特别是同时操作多个文件目录，或者远程控制多台主机，并行操作可以节约大量的时间。当被操作对象数目不大时，可以直接利用multiprocessing中的Process动态成生多个进程，10几个还好，但如果是上百个，上千个目标，手动的去限制进程数量却又太过繁琐，这时候进程池Pool发挥作用的时候就到了。
Pool可以提供指定数量的进程，供用户调用，当有新的请求提交到pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到规定最大值，那么该请求就会等待，直到池中有进程结束，才会创建新的进程来它。这里有一个简单的例子：
![]()
![]()
from multiprocessing import Process, Pool
import time, os
def Foo(i):
time.sleep(5)
print('in process[Foo]', os.getpid())
return i + 100
def Bar(arg): # 父进程去执行，而不是子进程调用
print('-->exec done:', arg)
print('in process[Bar]', os.getpid())
if __name__ == '__main__':
pool = Pool(5) # 允许进程池里同时放入5个进程 其他多余的进程处于挂起状态
for i in range(10):
pool.apply_async(func=Foo, args=(i,), callback=Bar)
# pool.apply(func=Foo, args=(i,))
print('end：', os.getpid())
pool.close() # close() 必须在join()前被调用
pool.join() # 进程池中进程执行完毕后再关闭，如果注释，那么程序直接关闭。
进程池
- pool.apply_async()用来向进程池提交目标请求。
- pool.join()是用来等待进程池中的worker进程执行完毕，防止主进程在worker进程结束前结束。但pool.join()必须使用在pool.close()或者pool.terminate()之后。
- close()跟terminate()的区别在于close()会等待池中的worker进程执行结束再关闭pool,而terminate()则是直接关闭。
- result.successful()表示整个调用执行的状态，如果还有worker没有执行完，则会抛出AssertionError异常。
- 利用multiprocessing下的Pool可以很方便的同时自动处理几百或者上千个并行操作，脚本的复杂性也大大降低.
