一 进程：
# 什么是进程 ： 运行中的程序，计算机中最小的资源分配单位
# 程序开始执行就会产生一个主进程
# python中主进程里面启动一个进程 —— 子进程
# 同时主进程也被称为父进程
# 父子进程之间的代码执行是异步的，各自执行自己的
# 父子进程之间的数据不可以共享
# 主进程会等待子进程结束之后再结束
二例子
#开启一个子进程
1 import os 2 import time 3 from multiprocessing import Process 4 def func(num): 5 print(num,os.getpid()) 6 time.sleep(0.5) 7 print(num,os.getpid()) 8 time.sleep(0.5) 9 if __name__ == '__main__': 10 p=Process(target=func,args=(10,)) 11 p.start() 12 print(os.getpid(),0) 13 time.sleep(1) 14 print(os.getpid(),1)
##父进程和子进程数据不可以共享，打印n为100
1 n=100 2 def func(): 3 global n 4 n=0 5 print('------') 6 time.sleep(3) 7 if __name__ == '__main__': 8 Process(target=func).start() 9 time.sleep(1) 10 print(n) 11 12 13 结果：打印n为100
#开启多个子进程
1 def func(n): 2 time.sleep(1) 3 print('_'*n) 4 if __name__ == '__main__': 5 l=[] 6 for i in range(10): 7 p=Process(target=func,args=(i,)) 8 p.start() 9 l.append(p) 10 11 print('子进程开始了') 12 for p in l:p.join() 13 print('10条信息已经发送完毕')
#守护进程
# 守护进程也是一个子进程
# 当主进程的代码执行完毕之后自动结束的子进程叫做守护进程
#当主进程结束的时候守护进程才结束
例子一：
1 def deamon_func(): #守护进程 2 while True: 3 print('我还活着') 4 time.sleep(0.5) 5 def wahaha():#子进程 6 for i in range(10): 7 time.sleep(1) 8 print(i*'#') 9 if __name__ == '__main__': 10 p2=Process(target=wahaha) 11 p2.start() 12 p=Process(target=deamon_func) #守护进程 13 p.daemon=True 14 p.start() 15 for i in range(3): #主进程 16 print(i*'*') 17 time.sleep(1)
当主进程执行完之后，deamon_func也就停止打印了
1 def deamon_func(): 2 while True: 3 print('我还活着') 4 time.sleep(0.5) 5 def wahaha(): 6 for i in range(10): 7 time.sleep(1) 8 print(i*'#') 9 if __name__ == '__main__': 10 p2=Process(target=wahaha) 11 p2.start() 12 p=Process(target=deamon_func) #这个是守护进程 13 p.daemon=True 14 p.start() 15 for i in range(3): #主进程 16 print(i*'##') 17 time.sleep(1) 18 p2.join()
这个是当wahaha里面的执行完毕了，守护进程才结束
总结
# 开启一个子进程 start
# 子进程和主进程是异步
# 如果在主进程中要等待子进程结束之后再执行某段代码：join
# 如果有多个子进程 不能在start一个进程之后就立刻join，把所有的进程放到列表中，等待所有进程都start之后再逐一join
# 守护进程 —— 当主进程的"代码"执行完毕之后自动结束的子进程叫做守护进程
二 进程池
#提交任务的两种方式：
#同步调用：提交完任务后，就在原地等待，等待任务执行完毕，拿到任务的返回值，才能继续下一行代码，导致程序串行执行
#异步调用+回调机制：提交完任务后，不在原地等待，任务一旦执行完毕就会触发回调函数的执行， 程序是并发执行
#异步调用
1 from concurrent.futures import ProcessPoolExecutor
2 def task(n): 3 print('%s is runing'%os.getpid()) 4 time.sleep(random.randint(1,3)) 5 return n**2 6 def handle(res): 7 res=res.result() 8 print('handle res %s' %res) 9 if __name__ == '__main__': 10 pool=ProcessPoolExecutor(2) #开启2个进程，每次执行2个 11 for i in range(5): 12 obj=pool.submit(task,i) 13 obj.add_done_callback(handle) 14 15 pool.shutdown() 16 print('主') 17 18 打印结果：12800 is runing 19 6264 is runing 20 6264 is runing 21 handle res 1 22 12800 is runing 23 handle res 0 24 6264 is runing 25 handle res 4 26 handle res 16 27 handle res 9 28 主
#同步调用，从上到下依次执行
1 from concurrent.futures import ProcessPoolExecutor
2 def task(n): 3 print('%s is runing'%os.getpid()) 4 time.sleep(random.randint(1,3)) 5 return n**2 6 def handle(res): 7 print('handle res %s' %res) 8 if __name__ == '__main__': 9 pool=ProcessPoolExecutor(3) 10 for i in range(5): 11 res=pool.submit(task,i).result() 12 handle(res) 13 pool.shutdown() 14 print('主') 15 16 执行结果： 17 16128 is runing 18 handle res 0 19 17120 is runing 20 handle res 1 21 7060 is runing 22 handle res 4 23 16128 is runing 24 handle res 9 25 17120 is runing 26 handle res 16 27 主
三 socketserver（用的就是多进程）
服务端：
1 import time 2 import socketserver 3 class Myserver(socketserver.BaseRequestHandler): 4 def handle(self): 5 conn = self.request 6 print(conn) 7 time.sleep(3) 8 conn.send(b'hello') 9 time.sleep(5) 10 conn.send(b'hello2') 11 # socketserver 12 # socket 13 14 myserver = socketserver.ThreadingTCPServer(('127.0.0.1',9000),Myserver) 15 myserver.serve_forever() 16 17 # socketserver所启动的服务端是不能有input操作的 18 # server端一般都是根据client端的要求去执行固定的代码
客户端：
1 import socket 2 sk=socket.socket() 3 sk.connect(('127.0.0.1',9000)) 4 print(sk.recv(1024)) 5 print(sk.recv(1024)) 6 sk.close()