9-1进程，进程池和socketserver

一 进程：

# 什么是进程 ： 运行中的程序，计算机中最小的资源分配单位
# 程序开始执行就会产生一个主进程
# python中主进程里面启动一个进程 —— 子进程
# 同时主进程也被称为父进程
# 父子进程之间的代码执行是异步的，各自执行自己的
# 父子进程之间的数据不可以共享
# 主进程会等待子进程结束之后再结束

二例子
#开启一个子进程

 import os
 import time
 from multiprocessing import Process
 def func(num):
     print(num,os.getpid())
     time.sleep(0.5)
     print(num,os.getpid())
     time.sleep(0.5)
 if __name__ == '__main__':
     p=Process(target=func,args=(10,))
     p.start()
     print(os.getpid(),0)
     time.sleep(1)
     print(os.getpid(),1)

##父进程和子进程数据不可以共享，打印n为100

 n=100
 def func():
     global n
     n=0
     print('------')
     time.sleep(3)
 if __name__ == '__main__':
     Process(target=func).start()
     time.sleep(1)
     print(n)

 结果：打印n为100

#开启多个子进程

 def func(n):
     time.sleep(1)
     print('_'*n)
 if __name__ == '__main__':
     l=[]
     for i in range(10):
         p=Process(target=func,args=(i,))
         p.start()
         l.append(p)

     print('子进程开始了')
     for p in l:p.join()
     print('10条信息已经发送完毕')

#守护进程

# 守护进程也是一个子进程
# 当主进程的代码执行完毕之后自动结束的子进程叫做守护进程
#当主进程结束的时候守护进程才结束
例子一：

 def deamon_func(): #守护进程
     while True:
         print('我还活着')
         time.sleep(0.5)
 def wahaha():#子进程
     for i in range(10):
         time.sleep(1)
         print(i*'#')
 if __name__ == '__main__':
     p2=Process(target=wahaha)
     p2.start()
     p=Process(target=deamon_func) #守护进程
     p.daemon=True
     p.start()
     for i in range(3): #主进程
         print(i*'*')
         time.sleep(1)
当主进程执行完之后，deamon_func也就停止打印了

 def deamon_func():
     while True:
         print('我还活着')
         time.sleep(0.5)
 def wahaha():
     for i in range(10):
         time.sleep(1)
         print(i*'#')
 if __name__ == '__main__':
     p2=Process(target=wahaha)
     p2.start()
     p=Process(target=deamon_func) #这个是守护进程
     p.daemon=True
     p.start()
     for i in range(3): #主进程
         print(i*'##')
         time.sleep(1)
     p2.join()

这个是当wahaha里面的执行完毕了，守护进程才结束

总结

# 开启一个子进程 start
# 子进程和主进程是异步
# 如果在主进程中要等待子进程结束之后再执行某段代码：join
# 如果有多个子进程 不能在start一个进程之后就立刻join，把所有的进程放到列表中，等待所有进程都start之后再逐一join
# 守护进程 —— 当主进程的"代码"执行完毕之后自动结束的子进程叫做守护进程
二 进程池

#提交任务的两种方式：
#同步调用：提交完任务后，就在原地等待，等待任务执行完毕，拿到任务的返回值，才能继续下一行代码，导致程序串行执行
#异步调用+回调机制：提交完任务后，不在原地等待，任务一旦执行完毕就会触发回调函数的执行， 程序是并发执行

#异步调用

 1 from concurrent.futures import ProcessPoolExecutor

 def task(n):
     print('%s is runing'%os.getpid())
     time.sleep(random.randint(1,3))
     return n**2
 def handle(res):
     res=res.result()
     print('handle res %s' %res)
 if __name__ == '__main__':
     pool=ProcessPoolExecutor(2) #开启2个进程，每次执行2个
     for i in range(5):
         obj=pool.submit(task,i)
         obj.add_done_callback(handle)

     pool.shutdown()
     print('主')

 打印结果：12800 is runing
 6264 is runing
 6264 is runing
 handle res 1
 12800 is runing
 handle res 0
 6264 is runing
 handle res 4
 handle res 16
 handle res 9
 主

#同步调用，从上到下依次执行

 1  from concurrent.futures import ProcessPoolExecutor

 def task(n):
     print('%s is runing'%os.getpid())
     time.sleep(random.randint(1,3))
     return n**2
 def handle(res):
     print('handle res %s' %res)
 if __name__ == '__main__':
     pool=ProcessPoolExecutor(3)
     for i in range(5):
         res=pool.submit(task,i).result()
         handle(res)
     pool.shutdown()
     print('主')

 执行结果：
 16128 is runing
 handle res 0
 17120 is runing
 handle res 1
 7060 is runing
 handle res 4
 16128 is runing
 handle res 9
 17120 is runing
 handle res 16
 主

三 socketserver（用的就是多进程）
服务端：

 import time
 import socketserver
 class Myserver(socketserver.BaseRequestHandler):
     def handle(self):
         conn = self.request
         print(conn)
         time.sleep(3)
         conn.send(b'hello')
         time.sleep(5)
         conn.send(b'hello2')
 # socketserver
 # socket

 myserver = socketserver.ThreadingTCPServer(('127.0.0.1',9000),Myserver)
 myserver.serve_forever()

 # socketserver所启动的服务端是不能有input操作的
 # server端一般都是根据client端的要求去执行固定的代码

客户端：

 import socket
 sk=socket.socket()
 sk.connect(('127.0.0.1',9000))
 print(sk.recv(1024))
 print(sk.recv(1024))
 sk.close()