进程池与线程池 协程代码演示Gevent

进程池与线程池
计算机的性能是有限的，不能无限的开启进程和线程。
创建进程池，把并发任务的个数控制在计算机可承受范围之内

进程池（计算密集型用多进程）
方案1

方案1：等进程全部运行完毕统一拿返回值，需要处理返回值结果时采用并发的形式去处理结果效率最高，比较占用计算机的资源
from concurrent.futures import ProcessPoolExecutor
import os, time, random


def task(n):
    print("%s is running" % os.getpid())
    time.sleep(random.randint(1, 3))
    return n ** 2


if __name__ == '__main__':
    # print(os.cpu_count())     # 查看计算机的cpu是几核的,本机是8核的
    pool = ProcessPoolExecutor(
        max_workers=8)  # 主进程开启进程池，ProcessPoolExecutor（）如果不传参的话计算机的cpu是几核的，那么就开几个进程，传参的话，传多少值就开几个进程。
    l = []
    for i in range(19):  # 进程池里面有8个进程，从始至终都是者8个进程，进程池里面的进程不会运行完一个就直接结束掉，会等这19个任务全部运行完毕才会结束进程
        future = pool.submit(task, i)  # .submit是异步的方式提交任务，task是需要运行的函数，i是传入task的参数
        l.append(future)

    pool.shutdown(wait=True)  # shutdown(统计进程池里面的进程个数，不允许在往进程池里面提交新的任务了)，wait=True，每运行完一个任务就会减一，直到任务减成0，等待所有任务运行完毕
    print("主")
    for obj in l:
        print(obj.result())     # obj.result()等任务运行完毕统一拿返回值，这种方式采用并发的形式处理结果效率最高

方案2

方案2：利用回调函数让主进程去处理结果，每运行完一个进程，主进程就开启一个线程，这样对计算机资源的利用比较合理
from concurrent.futures import ProcessPoolExecutor
import os, time, random


def task(n):
    print("%s is running" % os.getpid())
    time.sleep(random.randint(1, 3))
    return n ** 2


def handle(futrue):
    res = futrue.result()
    print("%s 正在处理结果：%s" % (os.getpid(), res))
    time.sleep(2)


if __name__ == '__main__':
    pool = ProcessPoolExecutor(max_workers=8)

    for i in range(19):
        pool.submit(task, i).add_done_callback(
            handle)  # .add_done_callback()回调函数，是指用来处理任务的函数，一旦一个任务运行完，会把运行完的结果当初参数传给被调的函数，会自动触发回调函数的运行

    pool.shutdown(wait=True)

线程池代码演示（io密集型用多线程）

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


def task(n):
    print("%s is running" % current_thread().name)
    time.sleep(random.randint(1, 3))
    return n ** 2


def handle(futrue):
    res = futrue.result()
    print("%s 正在处理结果：%s" % (current_thread().name, res))
    time.sleep(2)


if __name__ == '__main__':
    pool = ThreadPoolExecutor(max_workers=10)  # ThreadPoolExecutor()如果不传参数的话，开启线程的个数默认时cpu个数的5倍

    for i in range(19):
        pool.submit(task, i).add_done_callback(
            handle)  # .submit异步提交，.add_done_callback()回调函数，是指用来处理任务的函数，一旦一个任务运行完，会把运行完的结果当初参数传给被调的函数，会自动触发回调函数的运行

    pool.shutdown(wait=True)

协程就是单线程下实现的并发 (单线程最多可以抗住500多的并发)
特点：自己的应用程序实现多个人的调度
遇到io切换，可以将单线程的io降低到最低，提升单线程的运行效率
缺点：
1.不能实现并行
2.单线程下的多个任务一旦遇到io，整个线程都会阻塞，所有任务都会停滞

2、协程序的目的：
想要在单线程下实现并发
并发指的是多个任务看起来是同时运行的
并发=切换+保存状态

协程代码演示
下载安装gevent第三方库（cmd命令行里面输入命令pip3 install gevent）
协程代码演示Gevent（底层原理是封装了yield，遇到io保存当下的状态后会自动切换）
from gevent import monkey;monkey.patch_all()  # monkey.patch_all()会把代码所有的io行为转换成gevent能够识别的
import gevent
import time


def eat(name):
    print("%s eat 1" % name)
    time.sleep(2)  # 遇到io后切换到play
    print("%s eat 2" % name)


def play(name):
    print("%s play 1" % name)
    time.sleep(1)  # 遇到io后切换到eat，play也在io状态会进行来回的切换
    print("%s play 2" % name)


g1 = gevent.spawn(eat, "nana")
g2 = gevent.spawn(play, name="nana")
g1.join()  # print("主")运行完单线程就运行结束了，所有要用join让线程等待协程运行完再结束
g2.join()
print("主")

套接字程序实现协程并发案例

服务端
from gevent import monkey;monkey.path_all()
from socket import *
import gevent


def server(server_ip, port):        # 链接请求
    s = socket(AF_INET, SOCK_STREAM)
    # s.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
    s.bind((server_ip, port))   # 绑定ip跟端口
    s.listen(5)     # 监听请求
    while True:
        conn, addr = s.accept()     # 建立链接
        gevent.spawn(talk, conn, addr)  # 每建立一个链接提交一个协程对象，建立通信连接（异步提交）


def talk(conn, addr):       # 通信请求
    try:
        while True:
            res = conn.recv(1024)
            print("client %s:%s msg:%s" % (addr[0], addr[1], res))
            conn.send(res.upper())
    except Exception as e:
        print(e)
    finally:
        conn.close()


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

客户端
__author__ = "上海吴彦祖"

from socket import *

client = socket(AF_INET, SOCK_STREAM)
client.connect(("127.0.0.1", 8080))

while True:
    msg = input("输入：").strip()
    if not msg: continue

    client.send(msg.encode("utf-8"))
    msg = client.recv(1024)
    print(msg.decode("utf-8"))