import time
from concurrent.futures import ThreadPoolExecutor
import os
from gevent import os

pool = ThreadPoolExecutor(5)

def task(n):
    print(n,os.getpid())
    time.sleep(2)
    return n**2


list_1 = []
for i in range(20):
    res = pool.submit(task,i) #提交任务
    print(res.result())#等待任务的返回值
    list_1.append(res)

pool.shutdown() #关闭池子，等待池子中的任务运行完毕
for j in list_1:
    print('>>>',j.result())
print('主')

　　进程池：

　　进程池的使用和线程池差不多，区别仅只有包名不同，在进程池中我们可以验证以下池中的进程/线程是否是用的同样的进程/线程，使用os。getpid（）方法即可。

　　进程值不传值，里面的数值默认时cpu的个数。

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

# pool = ThreadPoolExecutor(5)
pool = ProcessPoolExecutor(5)


def task(n):
    print(n,os.getpid())
    time.sleep(2)
    return n**2

def callback(n):
    print(n.result())

if __name__ == '__main__':
    list_1 = []
    for i in range(20):
        res = pool.submit(task,i).add_done_callback(callback) #提交任务
        # print(res.result())#等待任务的返回值
        list_1.append(res)

　　异步回调：

　　除了上面使用的将返回的future对象添加到列表，再调用result（）方法返回其返回值以外，还可以对指派任务的返回值用

add_done_callback(callback)

　　方法，将该对象回调到callback（可以自定义）函数，由函数接纳处理该值，函数的参数就是任务的返回值，多个返回值要设置多个参数。

　　回调是在生产返回值时就运行的。

二。协程

　　协程就是在单线程的情况下实现并发。

　　一般程序的多道技术都是用切换+保存状态实现

　　在一般的cpu运算时，都是在五种状态中来回切换的，程序运行的5种状态：

　　1.新建。2.就绪。3.运行。4.阻塞。5.结束。

　　一般的，程序都是在2，3，4的状态来回切换，有2种情况。

　　1，程序遇到了io操作，由运行态进入到了阻塞态，直到io操作结束后再到阻塞态等待时间片。

　　2.程序的时间片用完，由运行态到就绪态。

　　协程的作用就是使得线程遇到io操作自己切换，运行的方式从1.变成2.线程持续不断的就绪，可以获得大量的cpu运算时间。

　　要实现这个功能需要考虑线程的保存状态问题。

　　这里就要用到迭代器的知识，yield，

　　yield可以保存上一次操作的状态，所以使用yield可以验证协程对计算密集型的线程操作后是否能加快效率。

#串行执行 0.8540799617767334
# import time
#
# def func1():
#     for i in range(10000000):
#         i+1
#
# def func2():
#     for i in range(10000000):
#         i+1
#
# start = time.time()
# func1()
# func2()
# stop = time.time()
# print(stop - start)

#基于yield并发执行  1.3952205181121826
# import time
# def func1():
#     while True:
#         10000000+1
#         yield
#
# def func2():
#     g=func1()
#     for i in range(10000000):
#         time.sleep(100)  # 模拟IO，yield并不会捕捉到并自动切换
#         i+1
#         next(g)
#
# start=time.time()
# func2()
# stop=time.time()
# print(stop-start)

　　可以看到，在计算密集的线程中，不断切换线程是不利于程序的运行的。

　　而yield不能识别io操作，而进行线程之间的切换的，所以需要引入一个模块gevent。

　　gevent是一个可以识别io的魔块，但不能识别time.sleep，所以还要调用另外一个模块识别time.sleep。

from gevent import monkey;monkey.patch_all() 
 # 由于该模块经常被使用 所以建议写成一行
from gevent import spawn
import time

　　spawn（）可以检测（）中的所有任务

def heng():
    print("哼")
    time.sleep(2)
    print('哼')

def ha():
    print('哈')
    time.sleep(3)
    print('哈')

def heiheihei():
    print('嘿嘿嘿')
    time.sleep(5)
    print('嘿嘿嘿')

start = time.time()
g1 = spawn(heng)
g2 = spawn(ha)  # spawn会检测所有的任务
g3 = spawn(heiheihei)
g1.join()
g2.join()
g3.join()
# heng()
# ha()
print(time.time() - start)
哼
哈
嘿嘿嘿
哼
哈
嘿嘿嘿
5.033252716064453

　　原本10秒钟的程序，现在需要5秒钟就可以运行结束了。

　　spawn可以将所有线程添加至一个列表，轮流运行其没有io操作的部分。

　　spawn有一个返回值g

　　注意，需要在程序最后等待所有程序都运行结束才结束程序，使用g.join方法。

三。使用gevent实现tcp的并发

from gevent import monkey;monkey.patch_all()
import socket
from gevent import spawn


server = socket.socket()
server.bind(('127.0.0.1',8080))
server.listen(5)


def talk(conn):
    while True:
        try:
            data = conn.recv(1024)
            if len(data) == 0:break
            print(data.decode('utf-8'))
            conn.send(data.upper())
        except ConnectionResetError as e:
            print(e)
            break
    conn.close()

def server1():
    while True:
        conn, addr = server.accept()
        spawn(talk,conn)

if __name__ == '__main__':
    g1 = spawn(server1)
    g1.join()