一、背景知识
顾名思义，进程即正在执行的一个过程。进程是对正在运行程序的一个抽象。进程的概念起源于操作系统，是操作系统最核心的概念，也是操作系统提供的最古老也是最重要的抽象概念之一。操作系统的其他所有内容都是围绕进程的概念展开的。
PS：即使可以利用的cpu只有一个（早期的计算机确实如此），也能保证支持（伪）并发的能力。将一个单独的cpu变成多个虚拟的cpu（多道技术：时间多路复用和空间多路复用+硬件上支持隔离）
#一 操作系统的作用：
1：封装了对硬件的操作过程，给应用提供好用的接口
2：对多个作业进行调度管理
进程 运行当中的程序叫做进程
#二 多道技术：
1.产生背景：针对单核，实现并发
ps：
现在的主机一般是多核，那么每个核都会利用多道技术
有4个cpu，运行于cpu1的某个程序遇到io阻塞，会等到io结束再重新调度，会被调度到4个
cpu中的任意一个，具体由操作系统调度算法决定。
2.空间上的复用：如内存中同时有多道程序
3.时间上的复用：复用一个cpu的时间片
强调：遇到io切，占用cpu时间过长也切，核心在于切之前将进程的状态保存下来，这样才能保证下次切换回来时，能基于上 次切走的位置继续运行
#三 进程调度算法
1、先来先服务
2、短作业优先算法
3、时间片轮转算法
4、多级反馈算法
#四 并行和并发的区别
1、2核2个人在同时跑
2、在一个精确的时间片刻，有不同的程序在执行
3、并发 在同一个时间段是同时执行，程序交替轮流使用资源
二、多进程的概念
进程只有三个状态 、就绪、运行、阻塞
1、进程：正在进行的一个过程或者说一个任务。而负责执行任务则是cpu。进程有如下三个状态：
当一个程序开始运行的时候，准备就绪，完后等待o/i操作，遇到阻塞，这是开始另一个程序开始执行
2、进程与程序的区别：程序仅仅只是一堆代码而已，而进程指的是程序的运行过程。
注意：同一个程序执行两次，那也是两个进程，例如快播同时打开两个 一个看视频一个做爱做的事 虽然是同一软件但是执行的是不同的操作，据说快播ceo2月底就出来了，我还欠他一个会员（年费那种）
举例（单核+多道，实现多个进程的并发执行）：
ebola需要做三件事 洗衣服、做饭、遛狗 但是同时时间只能做一件事、就需要Ebola 先洗一会衣服，再做回饭，再遛狗
3、并发与并行：
并发：针对只有一个cpu执行多个进程的情况。是伪并行，即看起来是同时运行。单个cpu+多道技术就可以实现并发。
举例： Ebola 需要同时洗衣服 遛狗 做饭 但是必须触发执行这一任务，就需要三件事情轮流交替做
并行：针对多个cpu执行多个进程的情况，并行也属于并发。
举例：
有四个核，六个任务，这样同一时间有四个任务被执行，假设分别被分配给了cpu1，cpu2，cpu3，cpu4，一旦任务1遇到I/O就被迫中断执行，此时任务5就拿到cpu1的时间片去执行，这就是单核下的多道技术 而一旦任务1的I/O结束了，操作系统会重新调用它(需知进程的调度、分配给哪个cpu运行，由操作系统说了算)，可能被分配给四个cpu中的任意一个去执行。
三、多进程实现
1、multiprocessing模块介绍
Python提供了multiprocessing。multiprocessing模块用来开启子进程，并在子进程中执行我们定制的任务（比如函数），该模块与多线程模块threading的编程接口类似。 multiprocessing模块的功能众多：支持子进程、通信和共享数据、执行不同形式的同步，提供了Process、Queue、Pipe、Lock等组件。 需要再次强调的一点是：与线程不同，进程没有任何共享状态，进程修改的数据，改动仅限于该进程内。
2、Process类介绍：为创建进程的类
主要方法：
#p为子进程 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开启的进程
主要属性：
#p为子进程 p.daemon：默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置 p.name:进程的名称 p.pid：进程的pid p.exitcode:进程在运行时为None、如果为–N，表示被信号N结束(了解即可) p.authkey:进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功（了解即可）
3、创建并开启子进程
方式一：
from multiprocessing import Process
import time
def work(name):
print('%s is piaoing' %name)
time.sleep(5)
print('%s piao end' %name)
if __name__=='__main__': #windows系统必须加
p=Process(target=work,args=('egon',))#args传参必须是个元组，也可以以字典形式传：kwargs={'name':'egon'}
p.start()
print('主进程')
方式二：
from multiprocessing import Process
import time
class work(Process):
def __init__(self,name):
super(work, self).__init__()
self.name=name
def run(self): #方法名run()不可以更换
print('%s is piaoing' %self.name)
time.sleep(5)
print('% piao end' %self.name)
if __name__=='__main__': #windows系统必须加
p=work('egon')
p.start()
print('主进程')
注意：进程的直接内存空间是彼此隔离的，如下例：
from multiprocessing import Process
n=100 #在windows系统中应该把全局变量定义在if __name__ == '__main__'之上
def work():
global n
n=0
print('子进程内: ',n)
if __name__ == '__main__':
p=Process(target=work)
p.start() #结果总为：0
print('主进程内: ',n) #结果总为：100
4、socket并发编程实例
可以实现多个客户端与服务端进行交流。
服务端：
from socket import *
from multiprocessing import Process
server=socket(AF_INET,SOCK_STREAM)
server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
server.bind(('127.0.0.1',8080))
server.listen(5)
def talk(conn):
while True:
try:
msg=conn.recv(1024)
if not msg:break
conn.send(msg.upper())
except Exception:
break
if __name__ == '__main__':
while True:
conn,client_addr=server.accept()
p=Process(target=talk,args=(conn,))
p.start()
客户端：
#多个客户端
from socket import *
client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8080))
while True:
msg=input('>>: ').strip()
if not msg:continue
client.send(msg.encode('utf-8'))
msg=client.recv(1024)
print(msg.decode('utf-8'))
5、jion()方法详解
join方法的主要作用是等待子进程结束后执行主进程。
并行效果：
from multiprocessing import Process
import time
def piao(name):
print('%s is piaoing' %name)
time.sleep(3)
print('%s is piao end' %name)
if __name__=='__main__':
p1=Process(target=piao,args=('egon',))
p2=Process(target=piao,args=('alex',))
p3=Process(target=piao,args=('yuanhao',))
p4=Process(target=piao,args=('wupeiqi',))
start_time=time.time()
p1.start()
p2.start()
p3.start()
p4.start()
p1.join()
p2.join()
p3.join()
p4.join()
end_time=time.time()
print(end_time-start_time) #结果为：3.多
print('主线程') #最后才被打印
解释：p.join()是让主线程等待p的结束，卡住的是主线程而绝非进程p，进程只要start就会在开始运行了,所以p1-p4.start()时,系统中已经有四个并发的进程了而我们p1.join()是在等p1结束,没错p1只要不结束主线程就会一直卡在原地,这也是问题的关键join是让主线程等,而p1-p4仍然是并发执行的,p1.join的时候,其余p2,p3,p4仍然在运行,等p1.join结束,可能p2,p3,p4早已经结束了,这样p2.join,p3.join.p4.join直接通过检测，无需等待所以4个join花费的总时间仍然是耗费时间最长的那个进程运行的时间。
串行效果：
from multiprocessing import Process
import time
def piao(name):
print('%s is piaoing' %name)
time.sleep(3)
print('%s is piao end' %name)
if __name__=='__main__':
p1=Process(target=piao,args=('egon',))
p2=Process(target=piao,args=('alex',))
p3=Process(target=piao,args=('yuanhao',))
p4=Process(target=piao,args=('wupeiqi',))
start_time=time.time()
p1.start()
p1.join()
p2.start()
p2.join()
p3.start()
p3.join()
p4.start()
p4.join()
end_time=time.time()
print(end_time-start_time) #结果为：12.多
print('主线程')
解释：以上p1,p2,p3,p4进程是上一个子进程执行完才逐一被启动，形成串行效果。