# 类似于是线程中的join功能
from concurrent.futures import ThreadPoolExecutor
import time
pool = ThreadPoolExecutor(3)
def task(name):
print('%s 开始' % name)
time.sleep(1)
print('%s 结束' % name)
if __name__ == '__main__':
for i in range(20):
pool.submit(task, '屌丝%s' % i)
# 放到for外面，等待所有任务执行完成，主线程再继续走
pool.shutdown(wait=True) # 等待所有任务完成，并且把池关闭
# # 问题，关了还能提交任务吗？不能再提交了
# pool.submit(task,'sdddd')
print('主') # 立马执行，20个线程都执行完了，再执行
2.定时器
# 多长时间之后执行一个任务
from threading import Timer
def task(name):
print('我是大帅比--%s' % name)
if __name__ == '__main__':
# t = Timer(2, task,args=('lqz',)) # 本质是开两个线程，延迟一秒执行
t = Timer(2, task, kwargs={'name': 'lqz'}) # 本质是开两个线程，延迟一秒执行
t.start()
import time
# 串行执行
# def func1():
# for i in range(100000000):
# i += 1
#
#
# def func2():
# for i in range(100000000):
# i += 1
#
#
# if __name__ == '__main__':
# ctime = time.time()
# func1()
# func2()
# print(time.time() - ctime) # 7s多一些
# 通过yield，实现保存状态加切换（自定义的切换，并不是遇到io才切，所有它并不能节约时间）
# 单纯的切换，不但不会提高效率，反而会讲低效率
def func1():
for i in range(100000000):
i += 1
yield
def func2():
g = func1() # 先执行一下func1
for i in range(100000000):
i += 1
next(g) # 回到func1执行
if __name__ == '__main__':
ctime = time.time()
func2()
print(time.time() - ctime) # 14.764776706695557
# 协程并不是真是存在的某个东西，而是程序员臆想出来的
# 程序员控制，不让自己的程序遇到io，看上去，就实现并发了
'''
优点如下：
协程的切换开销更小，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级
单线程内就可以实现并发的效果，最大限度地利用cpu
缺点如下：
协程的本质是单线程下，无法利用多核，可以是一个程序开启多个进程，每个进程内开启多个线程，每个线程内开启协程
协程指的是单个线程，因而一旦协程出现阻塞，将会阻塞整个线程
总结协程特点：
必须在只有一个单线程里实现并发
修改共享数据不需加锁
用户程序里自己保存多个控制流的上下文栈(需要保存状态)
附加：一个协程遇到IO操作自动切换到其它协程（如何实现检测IO，yield、greenlet都无法实现，就用到了gevent模块（select机制））
'''
4.greenlet模块
from greenlet import greenlet
import time
# 遇到io不会切，初级模块，gevent模块基于它写的，处理io切换
def eat():
print('我吃了一口')
time.sleep(1)
p.switch()
print('我又吃了一口')
p.switch()
def play():
print('我玩了一会')
e.switch()
print('我又玩了一会')
if __name__ == '__main__':
e = greenlet(eat)
p = greenlet(play)
e.switch()
5.gevent
# gevent基于greenlet写的，实现了遇见io自动切换
# import gevent
# import time
#
# def eat(name):
# print('%s 吃了一口' % name)
# gevent.sleep(1) # io操作
# print('%s 又吃了一口' % name)
#
#
# def play(name):
# print('%s 玩了一会' % name)
# gevent.sleep(2)
# print('%s 又玩了一会' % name)
#
#
# if __name__ == '__main__':
# ctim = time.time()
# e = gevent.spawn(eat,'lqz')
# p = gevent.spawn(play,'lqz')
# e.join() # 等待e执行完成
# p.join()
# print('主')
# print(time.time() - ctim) #2.0165154933929443
# 这个程序执行完成，最少需要多长时间 2s多一点
# ctim=time.time()
# eat('lqz')
# play('lqz')
# print(time.time()-ctim) # 3.0190377235412598
# 猴子补丁
# 以后使用,这一句必须写
from gevent import monkey;
monkey.patch_all()
import gevent
import time
def eat(name):
print('%s 吃了一口' % name)
time.sleep(1) # io操作，被猴子补丁替换之后，gevent.sleep()
print('%s 又吃了一口' % name)
def play(name):
print('%s 玩了一会' % name)
time.sleep(2)
print('%s 又玩了一会' % name)
if __name__ == '__main__':
ctim = time.time()
e = gevent.spawn(eat, 'lqz')
p = gevent.spawn(play, 'lqz')
e.join() # 等待e执行完成
p.join()
print('主')
print(time.time() - ctim) # 2.0165154933929443
6.猴子补丁
# class Monkey():
# def play(self):
# print('猴子在玩')
#
#
# class Dog():
# def play(self):
# print('狗子在玩')
# m=Monkey()
# m.play()
#
# m.play=Dog().play # 这个过程就叫猴子补丁，在程序运行过程中，动态修改
# m.play()
# 其他老师讲的
import json
import ujson
def monkey_patch_json():
json.__name__ = 'ujson'
json.dumps = ujson.dumps
json.loads = ujson.loads
monkey_patch_json()
# 其实用的是ujson
aa = json.dumps({'name': 'lqz', 'age': 19})
print(aa)
7.asyncio模块
# import time
# import asyncio
#
# # 把普通函数变成协程函数
# # 3.5以前这么写
# @asyncio.coroutine
# def task():
# print('开始了')
# yield from asyncio.sleep(1) #asyncio.sleep(1)模拟io
# print('结束了')
#
#
# loop=asyncio.get_event_loop() # 获取一个时间循环对象#
#
# # 协程函数加括号，并不会真正的去执行，它需要提交给loop，让loop循环着去执行
# # 协程函数列表
#
# ctime=time.time()
# t=[task(),task()]
# loop.run_until_complete(asyncio.wait(t))
# loop.close()
# print(time.time()-ctime)
import time
import asyncio
from threading import current_thread
# 表示我是协程函数,等同于3.5之前的装饰器
async def task():
print('开始了')
print(current_thread().name)
await asyncio.sleep(3) # await等同于原来的yield from
print('结束了')
async def task2():
print('开始了')
print(current_thread().name)
await asyncio.sleep(2)
print('结束了')
loop = asyncio.get_event_loop()
ctime = time.time()
t = [task(), task2()]
loop.run_until_complete(asyncio.wait(t))
loop.close()
print(time.time() - ctime)