day35 python socket 单线程的并发 io多路复用 协程 greenlet模块 gevent模块

day35 python socket 单线程的并发 io多路复用 协程 greenlet模块 gevent模块

 

一.socket相关

    1.socket: 所有的网络请求都是基于socket实现的,默认是阻塞的

    2.requests是用的socket的客户端

    3.socket到底哪端(谁)发生了变化

        如果客户端向服务端发起连接时, 则服务端发生了变化

        如果服务端向客户端发送数据时, 则客户端发生了变化

            conn,addr = server.accept()

            conn.recv()

    4.如果想要提高并发(目前有以下两种)

        多进程: 计算密集型

        多线程: io密集型,如socket请求

 

二.单线程的并发

    需求: 模拟浏览器发送请求: 向百度发送请求搜索三个关键词

    1.单线程(串行): 

        使用requests模块

import requests

key_list = ['bajie','wukong','datang']

 

for item in key_list:

    ret = requests.get(

        url="https://www.baidu.com/s?wd=%s" % (item,),

        headers = {"User-Agent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:69.0) Gecko/20100101 Firefox/69.0"}

    )

    print(ret.text)

    2.单线程(串行):

        用socket解析requests的原理

import socket

 

def task(key):

    client = socket.socket()

    client.connect(('www.baidu.com',80))            #阻塞: 和百度创建连接

    client.sendall(b'GET /s?wd=wukong HTTP/1.0\r\nHost: www.baidu.com\r\n\r\n')

                                                    #告诉百度我的请求, 用的是http协议(数据格式)

    data_list = []

    while 1:

        data = client.recv(4096)                    #等着接收百度的回复

        if not data:

            break

        data_list.append(data)

    body = b''.join(data_list)

    print(body)

key_list = ['bajie','wukong','datang']               ##

for item in key_list:

    task(item)

    3.多线程(并发)

import socket

import threading

 

def task(key):

    client = socket.socket()

    client.connect(('www.baidu.com',80))              #阻塞: 和百度创建连接

    client.sendall('GET /s?wd=wukong HTTP/1.0\r\nHost: www.baidu.com\r\n\r\n'.encode('utf-8'))    

                                                      #告诉百度我的请求, 用的是http协议(数据格式)

    data_list = []

    while 1:

        data = client.recv(4096)                      #等着接收百度的回复

        if not data:

            break

        data_list.append(data)

    body = b''.join(data_list)

    print(body)

key_list = ['bajie','wukong','datang']                ##

for item in key_list:

    t = threading.Thread(target=task,args=(item,))

    t.start()

    4.多线程并发时可能出现的问题

        4.1.问题: 

            假设连接非常慢, 三个人就傻傻地等着,不能做其他事

        4.2.怎么解决? 

            如果发现是io等待, 那么我就先把请求发出去, 然后去干其他事.

            又假设连接请求是一个一个回来的, 那么等这个io请求回来了, 我再处理, 就实现了单线程的并发

        4.3.单线程的并发本质是什么?

            单线程的io操作不等待

        4.4.单线程的并发如何实现?

            需解决: socket如何让io不等待

            需解决: 如何知道结果回来了

    5.单线程(并发)

        5.1.socket如何让io不等待: 把阻塞变成不阻塞

            client.setblocking(False)

import socket

def task(key):

    client = socket.socket()

    client.setblocking(False)                             #socket默认是阻塞的: 那么我可以给它设置成不是阻塞的; 但是客户端再去连接的时候会报错

    try:

        client.connect(('www.baidu.com',80))              #加个异常处理: 上面设置了原来阻塞的位置不再阻塞, 这句执行了, 但是报错

    except BlockingIOError as e:

        pass

    #此时我这里需要有个检测机制, 检测到连接成功, 才能继续下面的操作

 

    client.sendall('GET /s?wd=wukong HTTP/1.0\r\nHost: www.baidu.com\r\n\r\n'.encode('utf-8'))  

    data_list = []

    while 1:

        data = client.recv(4096)                  

        if not data:

            break

        data_list.append(data)

    body = b''.join(data_list)

    print(body)

key_list = ['bajie','wukong','datang']                    ##

for item in key_list:

    task(item)

 

 

        5.2.如何知道结果回来了: 使用io多路复用

            io多路复用的应用: 

                工作的时候没用过, 但是很多的东西都是基于这个做的

                io多路复用和socket的非阻塞,实现了单线程的并发

            作用:

                检测多个socket是否已经发生变化(是否已经连接成功/是否已经获取数据)(rlist/wlist)

            语法:

                select.select(rlist=[],                    #检测列表发生变化则返回(返回数据了吗?)

                              wlist=[],                    #检测列表发生变化则返回(连接成功了吗?)

                              xlist=[],                    #检测列表发生变化则返回(有异常吗?)

                              timeout=0.005,               #检测的时间间隔

                              )

import socket

import select

 

client1 = socket.socket()                                #创建了一个socket

client1.setblocking(False)

try:

    client1.connect(('www.baidu.com',80))

except BlockingIOError as e:

    pass

 

client2 = socket.socket()                                #socket的非阻塞.立即又创建了一个socket

client2.setblocking(False)

try:

    client2.connect(('www.sogou.com',80))

except BlockingIOError as e:

    pass

 

client3 = socket.socket()                                #socket的非阻塞.立即又创建了一个socket

client3.setblocking(False)

try:

    client3.connect(('www.oldboyedu.com',80))

except BlockingIOError as e:

    pass

 

dat_list = [client1,client2,client3]

conn_list = [client1,client2,client3]

 

while True:                                             #不停地去检测socket的状态

    rlist,wlist,xlist = select.select(dat_list,conn_list,[],0.005)   

                                                        #每 0.005秒 去检测socket的状态: 连接成功了吗?返回数据了吗?有异常吗?

    for sk in wlist:                                    #处理连接成功的socket

        if sk == client1:

            sk.sendall('GET /s?wd=wukong HTTP/1.0\r\nHost: www.baidu.com\r\n\r\n'.encode('utf-8'))

        elif sk == client2:

            sk.sendall('GET /web?query=bajie HTTP/1.0\r\nHost: www.sogou.com\r\n\r\n'.encode('utf-8'))

        else:

            sk.sendall('GET /liaojie/index.html HTTP/1.0\r\nHost: www.oldboyedu.com\r\n\r\n'.encode('utf-8'))

        conn_list.remove(sk)                            #处理完连接, 把sk从连接列表里剔除掉, 不用在检测

 

    for sk in rlist:                                    #处理有数据回来的socket

        data_list = []

        while True:

            try:

                data = sk.recv(8096)                    #因为上面的setblocking(False), 所有阻塞的地方都不阻塞, 所以这里应报错

                data_list.append(data)

            except BlockingIOError as e:

                break

        body = b''.join(data_list)

        print(body)

        sk.close()                                      #接收完数据的sk,断开socket连接

        dat_list.remove(sk)                             #接收完数据的sk,把sk从数据检测的列表里剔除掉, 不用在检测

 

    if not dat_list:                                    #都下载完数据了, 就停止检测

        break

        5.3.总结

            基于io多路复用和socket实现并发请求

            比多线程节省资源: 通过一个线程做20个线程做的事情

三.基于事件循环的异步非阻塞的框架

        非阻塞: 不等待

        异步: 指的是一个回调的过程,前面的某个事情完成了,自动执行一个'回调'函数; 上面的例子异步还没体现出来

        事件循环: 循环地去做某个事

        基于事件循环的异步非阻塞框架: Twisted 

            已经实现上述功能的模块, python中开源的模块

        

四.自定义异步非阻塞模块: 实现单线程并发

    单线程并发的高级版: 

        和上面代码的原理一样, 只是封装好了

        而且体现了异步的特性: 下载完数据就自动执行我给它的函数

import socket

import select

 

class Foo(object):

    def __init__(self,sk,func):

        self.sk = sk

        self.func = func

    def fileno(self):

        return self.sk.fileno()

class Bajie(object):

    def __init__(self):                                  #初始化,搞两个空检测列表

        self.conn_list = []

        self.socket_list = []

        self.info_list = []

    def add(self,domain,func):                           #创建socket, 加入到检测列表中

        client = socket.socket()

        client.setblocking(False)

        try:

            client.connect((domain, 80))

        except BlockingIOError as e:

            pass

        obj = Foo(client,func)

        self.socket_list.append(obj)

        self.conn_list.append(obj)

        self.info_list.append(obj)

    def run(self):

        while True:                                       #不停地去检测fileno()的状态

            rlist, wlist, xlist = select.select(self.socket_list, self.conn_list, [],0.005)  

                                                          #每0.005秒去检测fileno()的状态: 连接成功了吗?返回数据了吗?有异常吗?

 

            for obj in wlist:                             #处理连接成功的obj

                if obj == self.info_list[0]:

                    obj.sk.sendall('GET /s?wd=wukong HTTP/1.0\r\nHost: www.baidu.com\r\n\r\n'.encode('utf-8'))

                elif obj == self.info_list[1]:

                    obj.sk.sendall('GET /web?query=bajie HTTP/1.0\r\nHost: www.sogou.com\r\n\r\n'.encode('utf-8'))

                else:

                    obj.sk.sendall('GET /liaojie/index.html HTTP/1.0\r\nHost: www.oldboyedu.com\r\n\r\n'.encode('utf-8'))

                self.conn_list.remove(obj)                #处理完连接, 把obj从连接列表里剔除掉, 不用在检测

            for obj in rlist:                             #处理有数据回来的obj

                data_list = []

                while True:

                    try:

                        data = obj.sk.recv(8096)          #因为上面的setblocking(False), 所有阻塞的地方都不阻塞, 所以这里应报错

                        data_list.append(data)

                    except BlockingIOError as e:

                        break

                body = b''.join(data_list)

                # print(body)                             #下载完不打印了, 而去执行他们各自的函数, (回调就是这样搞)

                obj.func(body)

                obj.sk.close()                            #接收完数据的obj,断开socket连接

                self.socket_list.remove(obj)              #接收完数据的obj,把obj从数据检测的列表里剔除掉, 不用在检测

 

            if not self.socket_list:                      #都下载完数据了, 就停止检测

                break

def baidu_func(body):

    print('www.baidu.com--->',body)

def sogou_func(body):

    print('www.sogou.com--->', body)

def old_func(body):

    print('www.oldboyedu.com--->', body)

 

t1 = Bajie()

t1.add('www.baidu.com',baidu_func)                        #异步的体现: 当执行完前面的动作, 自动执行baidu_func函数

t1.add('www.sogou.com',sogou_func)

t1.add('www.oldboyedu.com',old_func)

t1.run()

 

五.总结: 

    1.socket默认是阻塞的, 体现在连接和接收数据, 但是可以使用client.setblocking(False)变成非阻塞

    2.io多路复用的作用: 

        检测多个socket是否发生变化

        使用的select是调用的操作系统的功能

        操作系统检测socket是否发生变化的三种模式:

            select:原始的, 对检测的socket的个数有限制: 1024 个, 内部实现时用的是循环检测        :select.select()

            poll:对检测的socket的个数不再限制: 内部实现时还是循环检测(水平触发)

            epoll:对检测的socket的个数不再限制: 内部实现时不再是检测, 而是等着socket报告给我(边缘触发)    :select.epoll()

            windows只支持select.select()

            linux是都支持的, epoll会比select用法上复杂一点点

    3.以后完成某件事提高并发的方案:

        多进程

        多线程

        异步非阻塞模块:Twisted, scrapy框架(单线程完成并发)

            会有问题: 如果发100个请求,倒是可以一起发请求出去, 如果100个是 同时回来的, 这种一个线程就完蛋了

            怎么办: 

                控制请求的数量

                使用生产者消费者模型(比如单线程并发下载,下载的数据放到队列,多进程处理数据)

    4.什么是异步非阻塞(面试题)?

        非阻塞:不等待, 比如创建一个socket进行连接某个地址, 或者接收数据时, 默认都是阻塞的(等待连接成功,或接受到数据), 才执行后续的操作, 

            如果设置成setblocking(False)非阻塞, 以上两个过程就不再等待, 但是会报BlockingIOError错误, 这个错误只要捕获即可

        异步:通知和回调, 当我们完成某件事时,自动调用回调函数或自动执行某些操作, 比如做爬虫向某个地址发送请求, 当请求完成之后, 自动执行指定的回调函数(就是通知)

    5.什么是同步阻塞?

        阻塞: 等

        同步: 按顺序一个一个执行, 比如for循环

    6.io多路复用和性能有关系吗?

        只是检测, 要看你和谁配合

    7.需要懵懂的一个概念

        封装: 当别人不改变调用代码的时候, 但是还要有这个东西, 那么你就给它封装进去

 

 

六.协程(本质遇到io就切换)

    1.什么是协程:

        线程: 操作系统中存在的

        进程: 操作系统中存在的

        协程: 不是一个真实存在的东西, 和线程和进程不同, 是由程序员创造的

        协程: 可以认为是微线程, 对线程进行分片, 使线程可以在代码块之间进行来回切换执行,而不是原来的逐行执行

    2.如何让两个代码块可以来回切换执行?    

        2.1.比如下面的两个函数, 让程序员来控制, 先执行11,再执行33,回去执行22,再执行44

def f1():

    print(11)

    print(22)

def f2():

    print(33)

    print(44)

f1()

f2()

        2.2.使用greenlet模块

            装包: pip3 install greenlet

import greenlet

def f1():

    print(11)

    gr2.switch()

    print(22)

    gr2.switch()

def f2():

    print(33)

    gr1.switch()

    print(44)

gr1 = greenlet.greenlet(f1)                    #创建了两个协程gr1,gr2

gr2 = greenlet.greenlet(f2)     

 

gr1.switch()                                    #执行协程gr1

    3.协程存在的意义?

        协程: 人为进行进程代码切换

        单纯的协程是没有任何用处的, 可能会让性能更低

        用作通过单线程实现并发: 单纯的它自己无法实现

            需要额外 + 一段代码配合(代码里面一旦遇到io操作, 就通过协程切换出去执行其他的代码)

            即协程 + 遇到io就切换

    4.gevent模块

        装包: pip3 install gevent

        内部封装了 greenlet + 遇到io就切换

from gevent import monkey

monkey.patch_all()                                             #必须要有; 以后代码中遇到IO操作, 内部会自动执行greenlet的switch进行切换  (patch 补丁)

 

import requests

import gevent

 

def get_page(url):

    rst = requests.get(url)

    print(url, rst.content)

 

gevent.joinall(

    [

        gevent.spawn(get_page,'https://www.python.org/'),       #协程1    (spawn: 产卵)

        gevent.spawn(get_page,'https://www.yahoo.com/'),        #协程2

        gevent.spawn(get_page,'https://github.com/')            #协程3

    ]

)

 

    5.总结

        5.1.什么是协程?

            协程也可以称之为微线程, 就是开发者控制着线程的执行流程: 控制先执行某段代码然后再切换到另外函数执行

        5.2.协程可以提高并发吗?

            协程自己本身无法实现并发(甚至性能会降低)

            协程 + IO切换性能提高

        5.3.进程,线程,协程的区别?

            进程:

            线程:

            协程:

        5.4.如果是单线程并发:(以下两个方式本质上是一样的)

            gevent: 协程 + io切换

            Twisted: 基于事件循环的异步非阻塞模块框架

            协程没有回调函数, 但是它可以自动切换

            协程本质上用的操作系统的一个库, 内部用的是也是事件循环

            所以这两个用哪个都一样的

 

    6.手动实现协程: yield关键字生成器

def f1():

    print(11)

    yield

    print(22)

    yield

    print(33)

def f2():

    print(44)

    yield

    print(55)

    yield

    print(66)

 

v2 = f2()

v1 = f1()

 

v1.__next__()                                                       #用生成器就可以控制两个函数中的代码来回交替

next(v2)

next(v1)

v2.__next__()