各种模块：
from gevent import monkey;monkey.patch_all()
import time
from gevent import spawn
import select
from multiprocessing import Process,Semaphore,RLock,Event,JoinableQueue
from threading import Thread,Semaphore,Event,RLock
import queue
from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
pool1 = ProcessPoolExecutor()
pool2 = ThreadPoolExecutor()
a = queue.Queue()
b = queue.LifoQueue()
c = queue.PriorityQueue()
d = JoinableQueue()
x = Semaphore(5)
e = Event()
def task(tt):
print(tt) # tt 普通参数
x.acquire()
# print(1)
# time.sleep(2)
x.release()
# e.set()
return 'ok'
# TypeError: task1() takes 0 positional arguments but 1 was given
def task1(t):
print(t) # <Future at 0x31eb4d0 state=finished returned NoneType>
print(t.result()) # ok 返回的是提交进程，的结果；也就是说 add_done_callback 里的方法名，默认第一个参数是Future 对象，，，
# 即task这个任务提交之后的返回的对象。也就是说，这个add_done_callback是个对象方法。self。。。
# e.wait()
print('wl')
if __name__ == '__main__':
# for i in range(20):
# t1 = Thread(target=task)
# t1.start()
# t2 = Thread(target=task1)
# t2.start()
for i in range(20):
pool2.submit(task,i).add_done_callback(task1) # submit 提交
if i == 10:
pool2.shutdown() # RuntimeError: cannot schedule new futures after shutdown 关闭线程池，循环并没有结束，会再次提交任务，所以，要break
break
"""
异步提交
gevent模块本身无法检测常见的一些io操作
在使用的时候需要你额外的导入一句话
from gevent import monkey
monkey.patch_all()
又由于上面的两句话在使用gevent模块的时候是肯定要导入的
所以还支持简写
from gevent import monkey;monkey.patch_all()
"""
# def heng():
# print('哼')
# time.sleep(2)
# print('哼')
#
#
# def ha():
# print('哈')
# time.sleep(3)
# print('哈')
#
# def heiheihei():
# print('heiheihei')
# time.sleep(5)
# print('heiheihei')
#
#
# start_time = time.time()
# g1 = spawn(heng).join()
# g2 = spawn(ha)
# g3 = spawn(heiheihei)
# # g1.join()
# # g2.join() # 等待被检测的任务执行完毕 再往后继续执行
# # g3.join()
# # heng()
# # ha()
# # print(time.time() - start_time) # 5.005702018737793
# print(time.time() - start_time) # 3.004199981689453 5.005439043045044
多路复用IO：
"""
当监管的对象只有一个的时候 其实IO多路复用连阻塞IO都比比不上！！！
但是IO多路复用可以一次性监管很多个对象
server = socket.socket()
conn,addr = server.accept()
监管机制是操作系统本身就有的 如果你想要用该监管机制(select)
需要你导入对应的select模块
"""
import socket
import select
server = socket.socket()
server.bind(('127.0.0.1',8080))
server.listen(5)
server.setblocking(False)
read_list = [server]
while True:
r_list, w_list, x_list = select.select(read_list, [], [])
"""
帮你监管
一旦有人来了 立刻给你返回对应的监管对象
一开始只监管server，当有客户端连接，被监管的server，有了回应，所以返回的r_list中有server
添加连接对象到read_list，增加了一个监管的对象。当连接对象，有发送数据，那么，检测到了结果，返回的r_list，就有了连接对象。
也就是说被监管的对象，哪个有结果回应，就添加到r_list中，从而程序往下运行。
当连接断开时，也是一种结果，收到的信息为空。
"""
# print(res) # ([<socket.socket fd=3, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 8080)>], [], [])
# print(server)
# print(r_list)
print(read_list)
print(r_list,w_list,x_list) # r_list 一开始只有server，有了连接对象之后，只有连接对象。
for i in r_list: #
"""针对不同的对象做不同的处理"""
if i is server:
conn, addr = i.accept()
# 也应该添加到监管的队列中
read_list.append(conn)
print('111111111')
else:
res = i.recv(1024)
if len(res) == 0:
i.close()
# 将无效的监管对象 移除
read_list.remove(i)
print(res) # b''
continue
print(res)
i.send(b'heiheiheiheihei')