什么是进程？
程序不能单独执行，只有将程序装载到内存中，系统为它分配资源才能运行，而这种执行的过程就叫做进程。进程是操作系统调度的最小单位。
程序和进程的区别在于：程序是储存在硬盘上指令的有序集合，是静态的；进程是程序的一次执行过程，属于动态概念。
线程和进程的区别：
进程是资源的集合，进程要在CPU执行，必须要创建线程，至少要有一个线程在运行。
1.线程共享创建它的进程的地址空间。进程的内存空间是独立的。
2.线程可以直接访问其进程的数据段（不同线程共享同一个进程的数据），进程间不共享。
3.线程可以与其他线程进行通信，进程必须使用进程间通信（中间代理）与同级进程进行通信。
4.新的线程很容易创建，新的进程需要父进克隆。
5.线程可以直接操作和控制同一进程内的其它线程，而进程只能操作子进程。
6.对主线程的修改可能会影响到其它线程的行为。对父进程的修改不会影响子进程（不删除父进程的前提下）。
Process 类用来描述一个进程对象。创建子进程的时候，只需要传入一个执行函数和函数的参数即可完成 Process 示例的创建。
star() 方法启动进程。
join() 方法实现进程间的同步，等待所有进程退出。
close() 用来阻止多余的进程涌入进程池 Pool 造成进程阻塞。
multiprocessing.Process(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None) target 是函数名字，需要调用的函数
args 函数需要的参数，以 元组 的形式传入
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() 所有的进程都是由父进程启动的，所以发现此程序的父进程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() 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)
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() 进程池
在利用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没有执行完，则会抛出
- 利用multiprocessing下的Pool可以很方便的同时自动处理几百或者上千个并行操作，脚本的复杂性也大大降低.