Python之并发、并行、阻塞、非租塞、同步、异步、IO多路复用

一、并发并行

并发：表示执行多个任务的能力

并行：表示同一时刻执行多个任务

二、模拟socket发送http请求

三大步骤：创建连接 要发送的东西 然后数据回来接收    socket默认情况下阻塞

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import socket

client = socket.socket()
client.setblocking(False)  # 这里设置非阻塞  
# 百度创建连接：阻塞
try:
    client.connect(('www.baidu.com', 80))  # 执行了但报错
except BlockingIOError as e:
    pass

# 发送要东西了
client.sendall(b'GET /s?wd=hello HTTP/1.0
host:www.baidu.com

')

# 百度给我的回复
chunk_list = []
while True:
    try:
        # 阻塞
        chunk = client.recv(8096)
        if not chunk:
            break
        chunk_list.append(chunk)
    except BlockingIOError:
        pass

print(b''.join(chunk_list).decode('utf8'))

 三、基于单线程和IO多路复用发送多个任务（并发方法一非阻塞）

IO多路复用作用：只是检测socket的变化 是否连接成功 是否返回数据 是否可读可写  其实不光监听这个还有监听终端linux下 突出输入输出

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

conn_list   检测其中所有socket对象是否与服务器连接成功   可写
socket_list   检测服务器是否有数据给我返回来         可读
[]　　　　检测是否有错误
　　　　连接最大超出的时间为0.005秒
rlist     返回数据的放在rlist中
wlist     把连接成功的放在wlist列表中 

实现的方式有两种   

select.select(socket_list, conn_list, [], 0.005)
    select监听的socket_list, conn_list内部会调用列表中的每一个值得fileno方法，获取该返回值并去系统中检测
    方式一：
    select.select([client1, client2], [client1, client2], [], 0.005)
    方式二：高级版本  封装socket对象
    select.select([Foo(client1), Foo(client2)], [Foo(client1), Foo(client2)], [], 0.005)

#!/usr/bin/env python
# -*- coding:utf-8 -*-

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.so.com", 80))
except BlockingIOError as e:
    pass
socket_list = [client1, client2]
conn_list = [client1, client2]
while True:
    rlist, wlist, elist = select.select(socket_list, conn_list, [], 0.005)
    for sk in wlist:
        if sk == client1:
            sk.sendall(b'GET /s?wd=hello HTTP/1.0
host:www.baidu.com

')
        else:
            sk.sendall(b'GET /s?q=hello HTTP/1.0
host:www.so.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('utf8'))
        # print("----->", body)
        sk.close()
        socket_list.remove(sk)
    if not socket_list:
        break

"""
回调：异步本质（通知）
def callback(arg):
    print(arg)
func("www.baidu.com/s?wd=hello" callback)
print(123)
print(123)
print(123)
"""

 四、利用单线程实现高并发NB高级版本（高并发方法二异步非阻塞）

#!/usr/bin/env python
# -*- coding:utf-8 -*-

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)
            for sk in wlist:
                sk.sock.sendall(b'GET /s?wd=hello 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)
                sk.func(body)
                sk.sock.close()
                self.socket_list.remove(sk)
            if not self.socket_list:
                break


def baidu_response(body):
    print('百度下载的结果', body)


def sogou_response(body):
    print('搜狗下载的结果', body)


t1 = Nb()
t1.add('www.baidu.com', baidu_response)
t1.add('www.so.com', sogou_response)
t1.run()

 总结：

IO多路复用的作用： 检测多个socket是否发生变化
            操作系统检测socket是否发生变化 有三种模式
            select:最多1024个socket个数  循环去检测。windows下只有select
            poll:  不限制监听socket个数，循环去检测。(水平触发)
            epoll: 不限制监听socket个数，回调的方式(边缘触发)  windows下没有  触发的机制可以采用简单点儿的高低电平来理解
　　　  linux下select.epoll  有点复杂注册哪些等等操作  用法差不多select.select

            提高并发方案：多进程 多线程 异步非阻塞模块（Twisted）
            什么是异步非阻塞？
 　　　非阻塞， 不等待 比如：创建socket对某个地址进行连接，获取接收数据时就会等待，连接成功/接收到数据时，
            才执行后续操作，如果设置setblocking(False),上边两过程不再等待，但是要报错BlockingError，只要去捕获即可
            异步：（通知）执行完成之后自动执行回调函数或者自动执行某些操作（通知）最根本就是执行完某个任务自动调用我给他的函数
                比如：爬虫中向某个地址发送请求，当请求执行完成之后自动执行回调函数
                
            什么是同步阻塞？
            同步：按照顺序逐步执行
            阻塞：等待

　　　　这么多代码其实可以不用写 基于异步非阻塞的框架 基于事件循环（驱动） Twisted