进程池与线程池,协程

开进程开线程都需要消耗资源,只不过两者比较的情况线程消耗的资源比较少

在计算机能够承受范围之内最大限度的利用计算机

什么是池?

　　在保证计算机硬件安全的情况下最大限度的利用计算机

　　池其实是降低了程序的运行效率  但是保证了计算机硬件的安全

　　(硬件的发展跟不上软件的速度)

from concurrent.futures import ThreadPoolExecutor
import time

pool = ThreadPoolExecutor(5)
def task(n):
    print(n) 
    time.sleep(2)
    return n**2

t_list = []
for i in range(20):
   res = pool.submit(task,i)
        # print(res.result())  # 原地等待任务的返回结果
    t_list.append(res)

    pool.shutdown()  # 关闭池子 等待池子中所有的任务执行完毕之后 才会往下运行代码
for p in t_list:
    print('>>>:',p.result())

线程池

from concurrent.futures import ThreadPoolExecutor
import time


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

def task(n):
    print(n)
    time.sleep(1)
    return n**2

def call_back(n):
    print('拿到异步提交任务的返回结果:',n.result())

"""
提交任务的方式
    同步:提交任务之后 原地等待任务的返回结果  期间不做任何事情
    异步:提交任务之后 不等待任务的返回结果(异步的结果怎么拿??) 直接执行下一行代码
    
"""
"""
异步回调机制:当异步提交任务有返回结果之后,会自动触发回调函数的执行

"""

for i in range(10):
    pool.submit(task,i).add_done_callback(call_back)
    # 提交任务的时候 绑定一个回调函数 一旦该任务有结果 立刻执行对于的回调函数

进程池

from concurrent.futures ProcessPoolExecutor
import time
import os

pool = ProcessPoolExecutor()  # 默认是当前计算机cpu的个数
"""
池子中创建的进程/线程创建一次就不会再创建了
至始至终用的都是最初的那几个
这样的话节省了反复开辟进程/线程的资源
"""

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

def call_back(n):
    print('拿到了异步提交任务的返回结果:',n.result())


if __name__ == '__main__':
    for i in range(20):
        pool.submit(task,i).add_done_callback(call_back)

协程

　　进程:资源单位

　　线程:执行单位

　　协程:单线程下实现并发

并发 

　　切换+保存状态

　　ps:看起来像同时执行的  就可以称之为并发

协程:完全是程序员们想出来的名词

　　单线程下实现并发

并发的条件:

　　多道技术

　　　　空间上的复用

　　　　时间上的复用

　　　　　　切换+保存状态

程序员自己通过代码自己检测程序中的IO

一旦遇到IO自己通过代码切换

给操作系统的感觉是这个线程没有任何IO

ps:欺骗了操作系统  让它误认为这个程序一直没有IO

　　从而保证程序在运行态和就绪态来回切换

　　提升代码的运行效率

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

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

　　当你的任务是计算密集型的情况下  降低效率

import time
串行执行  0.10493969917297363
def func1():
    for i in range(1000000):
        i + 1
def func2():
    for i in range(1000000):
        i + 1
start = time.time()
func1()
func2()
print(time.time() - start)

基于yield并发执行    0.17088890075683594
def func1():
    while True:
        1000000 + 1
        yield
def func2():
    g = func1()
    for i in range(1000000):
        time.sleep(100)   # 模拟IO,yield并不会捕捉到并自动切换
        i + 1
        next(g)

start = time.time()
func2()
print(time.time() - start)

 gevent模块

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

def ha():
    print('ha')
    time.sleep(2)
    print('hhh')

start = time.time()
s1 = spawn(heng)    # spawn 会检测所有的任务
s2 = spawn(ha)
s1.join()
s2.join()
print(time.time() - start)

使用协程实现Tcp的服务端并发

服务端
from gevent import monkey;monkey.patch_all()
from gevent import spawn
import socket


sk = socket.socket()
sk.bind(('127.0.0.1',8080))
sk.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 = sk.accept()
        spawn(talk,conn)

if __name__ == '__main__':

    g1 = spawn(server1)
    g1.join()

客户端
import socket
from threading import Thread,current_thread

def client1():
    sk = socket.socket()
    sk.connect(('127.0.0.1',8080))
    n = 0
    while True:
        data = '%s %s'%(current_thread().name,n)
        sk.send(data.encode('utf-8'))
        data = sk.recv(1024)
        print(data.decode('utf-8'))
        n += 1

for i in range(30):
    t = Thread(target=client1)
    t.start()

多进程下开多线程

多线程下再开协程

IO模型

为了更好地了解IO模型，我们需要事先回顾下：同步、异步、阻塞、非阻塞

    同步（synchronous） IO和异步（asynchronous） IO，阻塞（blocking） IO和非阻塞（non-blocking）IO分别是什么，到底有什么区别？这个问题其实不同的人给出的答案都可能不同，比如wiki，就认为asynchronous IO和non-blocking IO是一个东西。这其实是因为不同的人的知识背景不同，并且在讨论这个问题的时候上下文(context)也不相同。所以，为了更好的回答这个问题，我先限定一下本文的上下文。

    本文讨论的背景是Linux环境下的network IO。本文最重要的参考文献是Richard Stevens的“UNIX® Network Programming Volume 1, Third Edition: The Sockets Networking ”，6.2节“I/O Models ”，Stevens在这节中详细说明了各种IO的特点和区别，如果英文够好的话，推荐直接阅读。Stevens的文风是有名的深入浅出，所以不用担心看不懂。本文中的流程图也是截取自参考文献。

    Stevens在文章中一共比较了五种IO Model：
    * blocking IO           阻塞IO
    * nonblocking IO      非阻塞IO
    * IO multiplexing      IO多路复用
    * signal driven IO     信号驱动IO
    * asynchronous IO    异步IO
    由signal driven IO（信号驱动IO）在实际中并不常用，所以主要介绍其余四种IO Model。

    再说一下IO发生时涉及的对象和步骤。对于一个network IO (这里我们以read举例)，它会涉及到两个系统对象，一个是调用这个IO的process (or thread)，另一个就是系统内核(kernel)。当一个read操作发生时，该操作会经历两个阶段：

#1）等待数据准备 (Waiting for the data to be ready)
#2）将数据从内核拷贝到进程中(Copying the data from the kernel to the process)

阻塞IO(blocking IO)

 

非阻塞IO(non-blocking IO)

多路复用IO(IO multiplexing)

异步IO(Asynchronous I/O)