• 9-1进程,进程池和socketserver


    一 进程:

    # 什么是进程 : 运行中的程序,计算机中最小的资源分配单位
    # 程序开始执行就会产生一个主进程
    # 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()
  • 相关阅读:
    leetcode 1. 两数之和
    leetcode 671. 二叉树中第二小的节点
    leetcode 100. 相同的树
    leetcode 110. 平衡二叉树
    leetcode 144. 二叉树的前序遍历
    1066. Root of AVL Tree (25)
    leetcode 100 相同的树
    leeCode 515 在每个树行中找最大值
    LeetCode 31.下一个排列
    面向对象UML中类关系
  • 原文地址:https://www.cnblogs.com/huningfei/p/9188327.html
Copyright © 2020-2023  润新知