并发编程 协程

浏览器/爬虫都是socket 客户端

如何提高并发?  多线程  :IO  多进程:计算

一.IO多路复用

作用:检测多个socket 是否发生变化(是否连接成功/是否获取数据) (可读/可写)

regests 模块

ret=requests.get('https://www.baidu.com/s?wd=alex')
#DNS解析，根据域名解析出IP 后面的为搜索关键字

socket

#socket 发送请求
import  socket
cilent=socket.socket()
cilent.connect(("www.baidui.com",80))
cilent.sendall(b'GET /s?wd=alex HTTP/1.0
host:www.baidu.com

')
data=cilent.recv(8096)
lst=[]
while 1:
    if not data:
        break
    lst.append(data)
list=b"".join(lst)
list.decode("utf8")

b"".join(lst)  使列表结成字符串

2.多线程解决并发 

import  socket
import requests
def func(key):
    cilent=socket.socket()
    cilent.connect(("www.baidui.com",80))
    cilent.sendall(b'GET /s?wd=%s HTTP/1.0
host:www.baidu.com

' % key)
    data=cilent.recv(8096)
    lst=[]
    while 1:
        if not data:
            break
        lst.append(data)
    list=b"".join(lst)
    list.decode("utf8")
import  threading
l=["zq","wa","wd"]

for item  in  l:
    t1=threading.Thread(target=func,args=(item))
    t1.start()

缺点: 这个需要等待,因为有阻塞,会在客户端connect,recv 时刻需要等待客户端 ,怎样才能不等待呢???

IO多路复用+socket 实现并发请求 (一个线程100个请求)

这里用到   client.setblocking(False) 

client = socket.socket()
client.setblocking(False) # 将原来阻塞的位置变成非阻塞（报错）
# 百度创建连接: 阻塞

try:#需要 避免
    client.connect(('www.baidu.com',80)) # 执行了但报错了
except BlockingIOError as e:
    pass

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

IO多路复用+socket 实现并发请求

import socket
import select

client1 = socket.socket()
client1.setblocking(False) # 百度创建连接: 非阻塞

try:
    client1.connect(('www.baidu.com',80))
except BlockingIOError as e:
    pass

client2 = socket.socket()
client2.setblocking(False) # 百度创建连接: 非阻塞
try:
    client2.connect(('www.sogou.com',80))
except BlockingIOError as e:
    pass

client3 = socket.socket()
client3.setblocking(False) # 百度创建连接: 非阻塞
try:
    client3.connect(('www.oldboyedu.com',80))
except BlockingIOError as e:
    pass

socket_list = [client1,client2,client3]#创建连接列表,有三个
conn_list = [client1,client2,client3]#再创建

while True:
    rlist,wlist,elist = select.select(socket_list,conn_list,[],0.005)#rlist
    # wlist中表示是否已经和socket建立连接对象,有返回值,可写 返回cilent
    #rlist中表示是否已经和socket有返回数据,有返回值,可读 返回cilent
    #[] 中 将错误信息返回空列表
    #0.005 最大0.005秒检测错误
    for sk in wlist:
        if sk == client1:
            sk.sendall(b'GET /s?wd=alex HTTP/1.0
host:www.baidu.com

')
        elif sk==client2:
            sk.sendall(b'GET /web?query=fdf HTTP/1.0
host:www.sogou.com

')
        else:
            sk.sendall(b'GET /s?wd=alex HTTP/1.0
host:www.oldboyedu.com

')
        conn_list.remove(sk)
    for sk in rlist:
        chunk_list = []
        while True:
            try:
                chunk = sk.recv(8096)
                if not chunk:#
                    break
                chunk_list.append(chunk)
            except BlockingIOError as e:
                break
        body = b''.join(chunk_list)
        # print(body.decode('utf-8'))
        print('------------>',body)
        sk.close()
        socket_list.remove(sk)
    if not socket_list:#这里指当列表中的cilent被取到时,把他们移出作为判断
        #直到把最后都取出
        break

用面向对象做IO多路复用

import socket
import select

class Req(object):
    def __init__(self,sk,func):
        self.sock = sk
        self.func = func

    def fileno(self):
        return self.sock.fileno()


class Nb(object):

    def __init__(self):
        self.conn_list = []
        self.socket_list = []

    def add(self,url,func):
        client = socket.socket()
        client.setblocking(False)  # 非阻塞
        try:
            client.connect((url, 80))
        except BlockingIOError as e:
            pass
        obj = Req(client,func)
        self.conn_list.append(obj)
        self.socket_list.append(obj)

    def run(self):

        while True:
            rlist,wlist,elist = select.select(self.socket_list,self.conn_list,[],0.005)
            # wlist中表示已经连接成功的req对象
            for sk in wlist:
                # 发生变换的req对象
                sk.sock.sendall(b'GET /s?wd=alex HTTP/1.0
host:www.baidu.com

')
                self.conn_list.remove(sk)
            for sk in rlist:
                chunk_list = []
                while True:
                    try:
                        chunk = sk.sock.recv(8096)
                        if not chunk:
                            break
                        chunk_list.append(chunk)
                    except BlockingIOError as e:
                        break
                body = b''.join(chunk_list)
                # print(body.decode('utf-8'))
                sk.func(body)
                sk.sock.close()
                self.socket_list.remove(sk)
            if not self.socket_list:
                break

def baidu_repsonse(body):
    print('百度下载结果：',body)

def sogou_repsonse(body):
    print('搜狗下载结果：', body)

def oldboyedu_repsonse(body):
    print('老男孩下载结果：', body)

t1 = Nb()
t1.add('www.baidu.com',baidu_repsonse)
t1.add('www.sogou.com',sogou_repsonse)
t1.add('www.oldboyedu.com',oldboyedu_repsonse)
t1.run()

3.协程

 概念:

进程,线程 操作系统中存在

协程,是由程序员创造出来的,不是一个单独存在的东西

协程:是为线程,对一个线程进行分片,使得线程在代码块之间来回切换执行,而不是在原来逐行执行

import  greenlet
def func1():
    print(11)
    f2.switch()
    print(22)
    f2.switch()
def func2():
    print(33)
    f1.switch()
    print(44)
f1=greenlet.greenlet(func1)
f2=greenlet.greenlet(func2)
f1.switch()

但是单独的协程没有什么作用

协程只是单纯的分片,但是用在线程上就可以节省宝贵的时间,

但是无法判断是否是IO进行分片,这时候就需要  pip3 install gevent 

from gevent import monkey
monkey.patch_all()#以后代码中遇到IO都会自动执行greenlet的switch进行切换
import requests
import gevent
def f1(url):
    ret=requests.get(url)
    print(url,ret.content)
def f2(url):
    ret=requests.get(url)
    print(url,ret.content)
def f3(url):
    ret=requests.get(url)
    print(url,ret.content)
gevent.joinall([
    gevent.spawn(f1,'https://www.python.org/'),#协程1
    gevent.spawn(f2, 'https://www.yahoo.com/'),
    gevent.spawn(f3, 'https://www.github.com/'),
])

总结：
   1. 什么是协程？
      协程也可以称为“微线程”，就是开发者控制线程执行流程，控制先执行某段代码然后再切换到另外函执行代码...来回切换。
   
   2. 协程可以提高并发吗？
      协程自己本身无法实现并发（甚至性能会降低）。
      协程+IO切换性能提高。
      
   3. 进程、线程、协程的区别？
      
   4. 单线程提供并发：
      - 协程+IO切换：gevent
      - 基于事件循环的异步非阻塞框架：Twisted

手动实现协程：yield关键字生成器 

            def f1():
                print(11)
                yield
                print(22)
                yield
                print(33)

            def f2():
                print(55)
                yield
                print(66)
                yield
                print(77)

            v1 = f1()
            v2 = f2()

            next(v1) # v1.send(None)
            next(v2) # v1.send(None)
            next(v1) # v1.send(None)
            next(v2) # v1.send(None)
            next(v1) # v1.send(None)
            next(v2) # v1.send(None)

总体总结

'''
1.本质上socket
2.如何提高并发 ?
多进程:计算 多线程:io
一.
1.通过客户端协议也可以浏览网页
2.协议 遵循
3.间接可以用requests 模块  或者用 socket 模块来引用
4.cilent.setblocking(False)将原来阻塞的位置变成非阻塞(报错)
报错捕获一下  try  except BlockingIOError as e:
作用:单线程遇到io 不等待
需要检测是否连接
***  io多路复用作用: 检测socket是否已将发生变化
(是否已经连接成功/是否已经获取数据) (可度/可写)
***
5. select.select()[] >>报错写入  0.005 >内部最多0.005检测错误
6.已经实现的模块 Twisted  基于事件循环实现的异步非阻塞框架
还用封装实现 (没听好)
7.总结;
1.socket默认阻塞,阻塞体现在
 connect recv
2. 如何让socket变成非阻塞
 setblocking(False)
3. io多路复用
 检测多个socket是否发生变化
4. 系统检测socket是否发生变化,三种模式
select "最多1024个socket;循环检测
 poil: (主动查询)不限制监听sockrt个数;循环检测(慢)水平触发
epoil : (举手,自己完成主动通知) 回调方式 边缘触发
Python模块：
select.select 
select.epoll 

5.提高并发方案:
多进程
多线程
异步非阻塞模块(Twisted)  scrapy框架（单线程完成并发）
5.提高并发方案:
控制好线程个数
生产者消费者模型
6.什么是 异步非阻塞?
-非阻塞 ,不等待
比如创建socket对某个地址进行connect、获取接收数据recv时默认都会等待（连接成功或接收到数据），才执行后续操作。
如果设置setblocking(False),以上两个过程就不再等待，但是会报BlockingIOError的错误，只要捕获即可。
异步:
返回一个函数继续调用,
通知,执行完成后自动执行回调函数局或自动执行某种操作
7.什么是同步阻塞?
阻塞 ,等
同步,按照顺序逐步执行

不如创建socket对某个地址


三.
协程,是由程序员创造出来的不是真实存在的东西
由用户控制
协程,就是微线程,对一个线程进程分片,使得线程在代码块之间来回切换执行,
而不是在原来逐行执行
单纯的协程无用
协程的存在意义:类似于单线程实现并发:遇到IO + 协程的切换可以提高性能
3.1
协程+IO切换>>站起来了  pip3 install gevent
from gevent import monkey
monkey.path_all() #默认将代码遇到的IO
总结:
1.什么是协程?
2.协程可以提高并发么?
3.进程,线程,协程的区别面试题?
4.单线程提供并发
-协程+IO切换 :gevent
-基于事件循环的异步非阻塞框架: Twisted

也可以通过yield

以后gevent  Twisted 写代码
三种模式:
select
poil
epoil