定时器、线程queue、进程池和线程池

1.定时器

指定n秒后，执行任务

 from threading import Timer,current_thread
 import os

 def hello():
     print("%s hello, world"%os.getpid())
     print("%s hello, world"%current_thread().name)

 t = Timer(3, hello)
 t.start()  # after 1 seconds, "hello, world" will be printed
 print(os.getpid())
 print(current_thread())

 #
 # <_MainThread(MainThread, started 12008)>
 # 12376 hello, world
 # Thread-1 hello, world

定时器

2.线程queue

2.1 先进先出

 import queue

 q=queue.Queue()
 q.put('first')
 q.put('second')
 q.put('third')

 print(q.get())
 print(q.get())
 print(q.get())
 '''
 结果(先进先出):
 first
 second
 third
 '''

先进先出

2.2 后进先出

 import queue

 q=queue.LifoQueue()
 q.put('first')
 q.put('second')
 q.put('third')

 print(q.get())
 print(q.get())
 print(q.get())
 '''
 结果(后进先出):
 third
 second
 first
 '''

后进先出

2.3 优先级队列（开了会员就要先出来）

存储数据时可以设置优先级队列。数字越小（可以为负数），优先级越高，取出来的是一个元组形式。

里面put什么值就取出来什么值，只是优先级的问题。

 import queue

 q=queue.PriorityQueue()
 #put进入一个元组,元组的第一个元素是优先级(通常是数字,也可以是非数字之间的比较),数字越小优先级越高
 q.put((20,'a'))
 q.put((10,'b'))
 q.put((30,'c'))

 print(q.get())
 print(q.get())
 print(q.get())
 '''
 结果(数字越小优先级越高,优先级高的优先出队):
 (10, 'b')
 (20, 'a')
 (30, 'c')
 '''

优先级队列

3.进程池和线程池

'''
1、什么时候用池：
    池的功能是限制启动的进程数或线程数，
    什么时候应该限制？？？
    当并发的任务数远远超过了计算机的承受能力时，即无法一次性开启过多的进程数或线程数时
    就应该用池的概念将开启的进程数或线程数限制在计算机可承受的范围内

2、同步vs异步
    同步、异步指的是提交任务的两种方式

    同步：提交完任务后就在原地等待，直到任务运行完毕后拿到任务的返回值，再继续运行下一行代码
    异步：提交完任务（绑定一个回调函数）后根本就不在原地等待，直接运行下一行代码，等到任务有
    返回值后会自动触发回调函数

'''
 concurrent.futures 高度封装的异步调用接口
 ProcessPoolExecutor 进程池 提供异步调用
 ThreadPoolExecutor  线程池 提供异步调用

 from socket import *

 sever = socket(AF_INET,SOCK_STREAM)
 sever.bind(("127.0.0.1",8080))
 sever.listen(5)
 # 无法实现并发，建立一个连接，进入通信循环，直到通信循环结束
 while True:
     conn,addr = sever.accept()
     while True:
         try:
             data = conn.recv(1024)
             if len(data) == 0:break
             conn.send(data.upper())
         except ConnectionResetError:
             break
     sever.close()

 from socket import *

 sever = socket(AF_INET,SOCK_STREAM)
 sever.bind(("127.0.0.1",8080))
 sever.listen(5)
 def task(conn):
     while True:
         try:
             data = conn.recv(1024)
             if len(data) == 0: break
             conn.send(data.upper())
         except ConnectionResetError:
             break
     sever.close()
 # 还是实现不了并发，只能实现串行
 while True:
     conn,addr = sever.accept()
     task(conn)

 from socket import *
 from threading import Thread

 sever = socket(AF_INET,SOCK_STREAM)
 sever.bind(("127.0.0.1",8080))
 sever.listen(5)
 def task(conn):
     while True:
         try:
             data = conn.recv(1024)
             if len(data) == 0: break
             conn.send(data.upper())
         except ConnectionResetError:
             break
     sever.close()

 # 启动一个子线程干通信的活
 # 每建立一个连接就开启一个子线程，交给子线程干通信的活，可以实现并发
 while True:
     conn,addr = sever.accept()

     t = Thread(target=task,args=(conn,))
     t.start()

 from socket import *
 from threading import Thread

 def task(conn):
     while True:
         try:
             data = conn.recv(1024)
             if len(data) == 0: break
             conn.send(data.upper())
         except ConnectionResetError:
             break
     sever.close()

 # 将while循环放到函数下面，可以往里面传入ip，port和半连接池的最大限制数
 # 这样做是已经实现并发了，但是如果有很多的客户请求，需要不停的建立线程数，电脑肯定是有上限的。
 # python中的线程是操作系统的原生线程，需要操作系统来调度，同时开启太多线程，操作系统调度不过来。
 # 限制线程数不是为了提高效率，是高并发情况下不得已而为之
 def sever_func(ip,port,backlog = 5):
     while True:
         sever = socket(AF_INET,SOCK_STREAM)
         sever.bind((ip, port))
         sever.listen(backlog)
         print("start-------")
         conn,addr = sever.accept()

         t = Thread(target=task,args=(conn,))
         t.start()

 if __name__ == '__main__':
     sever_func("127.0.0.1",8080)

串行到并发改进

同步

同步：提交完任务后就在原地等待，直到任务运行完毕后拿到任务的返回值，再继续运行下一行代码
同步调用并不是真正意义上的串行，只是他的取值方式让程序变成了串行的工作方式。

 from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
 import time
 import os

 def task(n):
     print("%s is running"%os.getpid())
     time.sleep(5)
     return n**2

 # 默认是cpu的个数
 # 如果直接在提交任务后拿到返回值就变成同步了
 if __name__ == '__main__':
     pool = ProcessPoolExecutor(4)
     l = []
     for i in range(1,10):
         future = pool.submit(task,i)
         l.append(future)
         # print(future)
         # print(future.result())
     pool.shutdown(wait=True)
     for m in l:
         print(m.result())

同步调用

异步　

异步：提交完任务（绑定一个回调函数）后根本就不在原地等待，直接运行下一行代码，等到任务有

返回值后会自动触发回调函数
回调函数：parse会在futrue有返回值时立刻触发，并且将future当作参数传给parse

 from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
 from threading import current_thread
 import os
 import time
 import random

 def task(n):
     print('%s run...' %current_thread().name)
     time.sleep(5)
     return n**2

 def parse(future):
     time.sleep(1)
     res=future.result()
     print('%s 处理了 %s' %(current_thread().name,res))

 if __name__ == '__main__':
     pool=ThreadPoolExecutor(4)
     start=time.time()
     for i in range(1,5):
         future=pool.submit(task,i)
         future.add_done_callback(parse) # parse会在futrue有返回值时立刻触发，并且将future当作参数传给parse
     pool.shutdown(wait=True)
     stop=time.time()
     print('主',current_thread().name,(stop - start))

异步调用+回掉函数