进程池和线程池、协程、TCP单线程实现并发

一、进程池和线程池

当被操作对象数目不大时，我们可以手动创建几个进程和线程，十几个几十个还好，但是如果有上百个上千个。手动操作麻烦而且电脑硬件跟不上，可以会崩溃，此时进程池、线程池的功效就能发挥了。我们可以通过维护一个进程池、线程池来控制进程数目和线程数目。在保证计算机硬件安全的情况下最大限度的利用计算机，池其实是降低了程序的运行效率，但是保证了计算机硬件的安全。

注意点：在使用进程池、线程池，Pool可以提供指定数量的进程，线程，供用户调用，当有新的请求提交到pool中时，如果池还没有满，那么就会创建一个新的进程，线程用来执行该请求，但如果池中的进程，线程数量已经达到规定的最大值，那么该请求就会等待，直到池中有进程，线程结束，就重新使用进程池、线程池中的进程，线程。

池子中创建的进程/线程创建一次就不会再创建了，至始至终都是使用最初的那几个，这样的话节省了反复开辟进程/线程的资源(******)

主要方法：

pool.submit(task,1)     #朝池子中提交任务  异步提交    task是函数，1是task的参数
pool.shutdown()    #关闭池子  等待池子中所有任务执行完毕之后才会往下运行代码

线程池和进程池创建的方法一样只是导入的模块不一样

回调函数add_done_callback,我们可以把耗时间（IO操作）的任务放在进程池中，然后指定回调函数(主进程负责执行)，这样主进程在执行回调函数时就省去了IO的过程，直接拿到的是任务的结果。

异步回调机制：当异步提交的任务有返回结果之后，会自动触发回调函数的执行。

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

# pool = ThreadPoolExecutor(5)   创建线程池  # 括号内可以传参数指定线程池内的线程个数 也可以不传  不传默认是当前所在计算机的cpu个数乘5
pool = ProcessPoolExecutor() 创建进程池  # 默认是当前计算机cpu的个数

def task(n):
    print(n,os.getpid())  # 查看当前进程号
    time.sleep(2)
    return n**2

def call_back(n):
    print('拿到了异步提交任务的返回结果:',n.result())  #submit提交任务返回值，需要result才能获取结果

"""
异步回调机制:当异步提交的任务有返回结果之后，会自动触发回调函数的执行

"""
if __name__ == '__main__':
    for i in range(20):
        pool.submit(task,i).add_done_callback(call_back)  # 提交任务的时候 绑定一个回调函数 一旦该任务有结果 立刻执行对于的回调函数
        
#submit提交任务task函数，当有返回值时，立刻把返回值传入回调函数       

二、协程

协程就是单线程下实现并发 ，协程：完全是程序员自己想出来的一个名词

程序员通过自己代码检测程序中的IO操作，一旦遇到IO自己通过代码切换，给操作系统的感觉是你这个线程没有任何的IO,从而保证程序在运行态和就绪态来回切换，提升代码的运行效率。

切换+保存状态就一定能够提升效率吗？？？

当你的任务是io密集型的情况下    会提升效率

当你的任务是计算密集型时       会降低效率

spawn会自动帮你检测任务有没有I/O,碰到I/O就切换

from gevent import monkey;monkey.patch_all()  # 由于该模块经常被使用 所以建议写成一行
from gevent import spawn
import time
"""
注意gevent模块没办法自动识别time.sleep等io情况
需要你手动再配置一个参数   monkey
"""

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()
print(time.time() - start)

#结果
哼
哈
嘿嘿嘿
哼
哈
嘿嘿嘿
5.012551546096802

三、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()

客户端  实现400个线程，模拟400个用户

import socket
from threading import Thread,current_thread

def client():
    client = socket.socket()
    client.connect(('127.0.0.1',8080))
    n = 0
    while True:

        data = '%s %s'%(current_thread().name,n)
        client.send(data.encode('utf-8'))
        res = client.recv(1024)
        print(res.decode('utf-8'))
        n += 1

for i in range(400):
    t = Thread(target=client)
    t.start()