线程三

一：线程池#

【1】基础概念：

（1）产生背景：

　　（1）当有大量的用户访问服务器的时候 如果为每个用户都开辟一个线程 

　　（2）计算机不能同时处理这么多的线程 内存也没这么多资源被消耗 如果处理太多的进程或者线程 会导致计算机崩溃

（2）解决办法：

　　（1）通过线程池限制最大的进程数或者线程数

　　（2）当每个线程或者进程处理完毕在处理其余线程或者进程

 

【2】线程池：

（1）作用：

　　（1）限制每次CPU处理的进程或者线程都是固定的

　　（2）在保证计算机硬件的情况下 尽量最大程度利用计算机

　　（3）其虽然降低了程序的运行效率 但是提高了计算机硬件安全性

PS：

　　（1）线程池可以为其传参数 传参数为几 则计算机处理最大的线程数就为多少

　　（2）如果不传默认为计算机CPU核数的5倍

　　（3）进程池可以为其传参数 传参数为几 则计算机处理最大的线程数就为多少

　　（4）如果不传默认为当前CPU核数的个数

 

（2）线程池使用方式：

例如：

from concurrent.futures import ThreadPoolExecutor
import time

# 最大线程数为 5
pool = ThreadPoolExecutor(5)


def run(n):
    print(n)
    time.sleep(2)


for i in range(20):
    # 提交任务的方式
    pool.submit(run, i)
    
    # 每次会循环打印5个

图解：

PS：

（1）上述submit为线程池提交任务

 提交任务的方式：

（1）同步：任务提交之后 原地等待 需要拿到程序执行结果才会执行接下来的代码

（2）异步：任务提交之后 无需等待 不需要拿到程序的执行结果 直接执行接下来的代码

 

（1）线程池的返回结果：

（1）在上述代码中submit内部源码可以看到为某个类实例化产生的对象

（2）如果需要获取结果可以通过result进行取值 

　　（1）如果线程池提交的任务没有返回值的情况下 其返回值为None

　　（2）如果提交的任务有返回值 则获取值为任务的返回值

　　（2）其会将程序的执行由并发转变成串行 程序执行效率会特别低

例如：

from concurrent.futures import ThreadPoolExecutor
import time
#
# 最大线程数为 5
pool = ThreadPoolExecutor(5)


def run(n):
    print(n)
    time.sleep(2)


for i in range(20):

    # submit为内部源码实例化产生的对象
    obj = pool.submit(run, i)
    # result取值
    print(obj.result())
'''
1:程序执行由并发变成串行
2：上述任务（submit提交的函数）没有返回值 故获取结果为None
'''

from concurrent.futures import ThreadPoolExecutor
import time

# 最大线程数为 5
pool = ThreadPoolExecutor(5)


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


for i in range(20):

    # submit为内部源码实例化产生的对象
    obj = pool.submit(run, i)
    # result取值
    print(obj.result())
'''
1:程序执行由并发变成串行
2：上述任务（submit提交的函数）有返回值 获取值
'''

 

（3）解决上述程序运行变成串行 执行效率低

　　（1）解决思路：

　　　　（1）可以首先将线程全部执行起来 将线程加入一个列表

　　　　（2）循环列表中的线程取值 打印取值结果

例如：

from concurrent.futures import ThreadPoolExecutor
import time

# 最大线程数为 5
pool = ThreadPoolExecutor(5)


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

t_list = []
for i in range(20):
    # submit为内部源码实例化产生的对象
    obj = pool.submit(run, i)
    # 将线程加入列表中
    t_list.append(obj)

# 循环打印列表
for j in  t_list:
    # 列表进行取值
    print('打印了第一个值>>:',j.result())

PS：

（1）但是上述拿到的结果比较错乱 因为只有当五个线程结束之后才能获取值

（2）然后继续打印线程 在获取值

 

（4）shutdown参数

作用:其会关闭线程池 等线程池提交任务结束之后 才会执行线程池下面的代码

 例如：

　　（1）上述代码取值结果 不够整齐 可以通过shutdown解决 

　　（2）等线程池任务全部都结束 才开始从池子取值

from concurrent.futures import ThreadPoolExecutor
import time
#
# 最大线程数为 5
pool = ThreadPoolExecutor(5)


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

t_list = []
for i in range(20):
    # submit为内部源码实例化产生的对象
    obj = pool.submit(run, i)
    # 将线程加入列表中
    t_list.append(obj)

pool.shutdown()
for j in  t_list:
    # 列表进行取值
    print('打印了第一个值>>:',j.result())

 

二：进程池#

 （1）使用方式

from concurrent.futures import ProcessPoolExecutor
import time
import os

# 最大进程数为 8
pool = ProcessPoolExecutor(8)


def run(n):
    print(n,os.getpid())
    time.sleep(2)
    return n**2

if __name__ == '__main__':

    t_list = []
    for i in range(20):
        # submit为内部源码实例化产生的对象
        obj = pool.submit(run, i)
        # 将线程加入列表中
        t_list.append(obj)

    pool.shutdown()
    for j in  t_list:
        # 列表进行取值
        print('打印了第一个值>>:',j.result())

 

（2）异步回调机制

定义：当异步提交的任务有返回结果 会自动触发回调函数的执行 通过回调函数获取上述任务的返回值

例如：

from concurrent.futures import ProcessPoolExecutor
import time
import os

# 最大进程数为 8
pool = ProcessPoolExecutor(8)


def run(n):
    print(n,os.getpid())
    time.sleep(2)
    return n**2

def call_back(n):
    print(n.result())

if __name__ == '__main__':

    t_list = []
    for i in range(20):

        # 调用上述的函数 此时拿到的上述
        obj = pool.submit(run, i).add_done_callback(call_back)
        # 将线程加入列表中
        t_list.append(obj)

 

三：协程#

（1）作用：单线程下实现并发

PS：协程是程序员自己意淫的名词

 

（2）并发的条件：

 　　（1）空间上的复用：多个软件共用一套计算机系统

　　（2）时间上的复用：切换 + 保存状态

 

（3）协程的方式：

　　（1）程序员自己通过代码检测程序的I/O操作

　　（2）如果遇到I/O操作 自己通过代码进行切换 

PS：

（1）主要就是欺骗操作系统 让操作系统误认为程序没有I/O操作

（2）同时允许程序一直处于就绪与允许态

 

（3）案例

　　（1）既然是并发就是上述代码肯定处于保存状态 接下来的执行结果 基于上次的保存状态

　　（2）yield可以让程序执行基于上次保存

例如：

import time
def func1():
    while True:
        10000000+1
        yield

def func2():
    g=func1()
    for i in range(10000000):
        time.sleep(100)  # 模拟IO，yield并不会捕捉到并自动切换
        i+1
        next(g)

start=time.time()
func2()
stop=time.time()

PS：其虽然可以帮我们进行状态保存 但是不能进行程序的切换

 

（4）gevent模块

作用：

（1）当程序遇到I/O操的时候 会自动进行切换

（2）但是没办法识别time input等I/O操作（需要monkey.patch_all 解决）

例如：

from gevent import monkey;monkey.patch_all()  # 由于该模块经常被使用 所以建议写成一行
from gevent import spawn
import time


def heng():
    print("哼")
    time.sleep(2)
    print('哼')

def ha():
    print('哈')
    time.sleep(3)
    print('哈')

def heiheihei():
    print('嘿嘿嘿')
    time.sleep(5)
    print('嘿嘿嘿')

start = time.time()
g1 = spawn(heng)
g2 = spawn(ha)  # spawn会检测所有的任务 当遇到任务有I/O会自动切换别的任务
g3 = spawn(heiheihei)
g1.join()
g2.join()
g3.join()

 

（5）协程实现TCP服务端并发：

from gevent import monkey;monkey.patch_all()
import socket
from gevent import spawn


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

if __name__ == '__main__':
    g1 = spawn(server1)
    g1.join()

import socket
from threading import Thread,current_thread


def client():
    client = socket.socket()
    client.connect(('127.0.0.1',8080))
    n = 0
    while True:

        data = '%s %s'%(current_thread().name,n)
        client.send(data.encode('utf-8'))
        res = client.recv(1024)
        print(res.decode('utf-8'))
        n += 1

for i in range(400):
    t = Thread(target=client)
    t.start()

 

I/O模型

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模型的区别就是在两个阶段上各有不同的情况。

2|0阻塞IO(blocking IO)

 

　　在linux中，默认情况下所有的socket都是blocking，一个典型的读操作流程大概是这样：

　　

　　当用户进程调用了recvfrom这个系统调用，kernel就开始了IO的第一个阶段：准备数据。对于network io来说，很多时候数据在一开始还没有到达（比如，还没有收到一个完整的UDP包），这个时候kernel就要等待足够的数据到来。

    而在用户进程这边，整个进程会被阻塞。当kernel一直等到数据准备好了，它就会将数据从kernel中拷贝到用户内存，然后kernel返回结果，用户进程才解除block的状态，重新运行起来。
    所以，blocking IO的特点就是在IO执行的两个阶段（等待数据和拷贝数据两个阶段）都被block了。

    几乎所有的程序员第一次接触到的网络编程都是从listen()、send()、recv() 等接口开始的，使用这些接口可以很方便的构建服务器/客户机的模型。然而大部分的socket接口都是阻塞型的。如下图

    ps：所谓阻塞型接口是指系统调用（一般是IO接口）不返回调用结果并让当前线程一直阻塞，只有当该系统调用获得结果或者超时出错时才返回。

      

　　实际上，除非特别指定，几乎所有的IO接口 ( 包括socket接口 ) 都是阻塞型的。这给网络编程带来了一个很大的问题，如在调用recv(1024)的同时，线程将被阻塞，在此期间，线程将无法执行任何运算或响应任何的网络请求。

    一个简单的解决方案：

#在服务器端使用多线程（或多进程）。多线程（或多进程）的目的是让每个连接都拥有独立的线程（或进程），这样任何一个连接的阻塞都不会影响其他的连接。

    该方案的问题是：

#开启多进程或都线程的方式，在遇到要同时响应成百上千路的连接请求，则无论多线程还是多进程都会严重占据系统资源，降低系统对外界响应效率，而且线程与进程本身也更容易进入假死状态。

    改进方案：    

#很多程序员可能会考虑使用“线程池”或“连接池”。“线程池”旨在减少创建和销毁线程的频率，其维持一定合理数量的线程，并让空闲的线程重新承担新的执行任务。“连接池”维持连接的缓存池，尽量重用已有的连接、减少创建和关闭连接的频率。这两种技术都可以很好的降低系统开销，都被广泛应用很多大型系统，如websphere、tomcat和各种数据库等。

    改进后方案其实也存在着问题：

#“线程池”和“连接池”技术也只是在一定程度上缓解了频繁调用IO接口带来的资源占用。而且，所谓“池”始终有其上限，当请求大大超过上限时，“池”构成的系统对外界的响应并不比没有池的时候效果好多少。所以使用“池”必须考虑其面临的响应规模，并根据响应规模调整“池”的大小。

    对应上例中的所面临的可能同时出现的上千甚至上万次的客户端请求，“线程池”或“连接池”或许可以缓解部分压力，但是不能解决所有问题。总之，多线程模型可以方便高效的解决小规模的服务请求，但面对大规模的服务请求，多线程模型也会遇到瓶颈，可以用非阻塞接口来尝试解决这个问题。

3|0非阻塞IO(non-blocking IO)

 

Linux下，可以通过设置socket使其变为non-blocking。当对一个non-blocking socket执行读操作时，流程是这个样子：

　　

　　从图中可以看出，当用户进程发出read操作时，如果kernel中的数据还没有准备好，那么它并不会block用户进程，而是立刻返回一个error。从用户进程角度讲 ，它发起一个read操作后，并不需要等待，而是马上就得到了一个结果。用户进程判断结果是一个error时，它就知道数据还没有准备好，于是用户就可以在本次到下次再发起read询问的时间间隔内做其他事情，或者直接再次发送read操作。一旦kernel中的数据准备好了，并且又再次收到了用户进程的system call，那么它马上就将数据拷贝到了用户内存（这一阶段仍然是阻塞的），然后返回。

    也就是说非阻塞的recvform系统调用调用之后，进程并没有被阻塞，内核马上返回给进程，如果数据还没准备好，此时会返回一个error。进程在返回之后，可以干点别的事情，然后再发起recvform系统调用。重复上面的过程，循环往复的进行recvform系统调用。这个过程通常被称之为轮询。轮询检查内核数据，直到数据准备好，再拷贝数据到进程，进行数据处理。需要注意，拷贝数据整个过程，进程仍然是属于阻塞的状态。

    所以，在非阻塞式IO中，用户进程其实是需要不断的主动询问kernel数据准备好了没有。

 

但是非阻塞IO模型绝不被推荐。

    我们不能否则其优点：能够在等待任务完成的时间里干其他活了（包括提交其他任务，也就是 “后台” 可以有多个任务在“”同时“”执行）。

    但是也难掩其缺点：

#1. 循环调用recv()将大幅度推高CPU占用率；这也是我们在代码中留一句time.sleep(2)的原因,否则在低配主机下极容易出现卡机情况
#2. 任务完成的响应延迟增大了，因为每过一段时间才去轮询一次read操作，而任务可能在两次轮询之间的任意时间完成。这会导致整体数据吞吐量的降低。

    此外，在这个方案中recv()更多的是起到检测“操作是否完成”的作用，实际操作系统提供了更为高效的检测“操作是否完成“作用的接口，例如select()多路复用模式，可以一次检测多个连接是否活跃。

4|0多路复用IO(IO multiplexing)

 

　　IO multiplexing这个词可能有点陌生，但是如果我说select/epoll，大概就都能明白了。有些地方也称这种IO方式为事件驱动IO(event driven IO)。我们都知道，select/epoll的好处就在于单个process就可以同时处理多个网络连接的IO。它的基本原理就是select/epoll这个function会不断的轮询所负责的所有socket，当某个socket有数据到达了，就通知用户进程。它的流程如图：

　　当用户进程调用了select，那么整个进程会被block，而同时，kernel会“监视”所有select负责的socket，当任何一个socket中的数据准备好了，select就会返回。这个时候用户进程再调用read操作，将数据从kernel拷贝到用户进程。
    这个图和blocking IO的图其实并没有太大的不同，事实上还更差一些。因为这里需要使用两个系统调用(select和recvfrom)，而blocking IO只调用了一个系统调用(recvfrom)。但是，用select的优势在于它可以同时处理多个connection。

    强调：

    1. 如果处理的连接数不是很高的话，使用select/epoll的web server不一定比使用multi-threading + blocking IO的web server性能更好，可能延迟还更大。select/epoll的优势并不是对于单个连接能处理得更快，而是在于能处理更多的连接。

    2. 在多路复用模型中，对于每一个socket，一般都设置成为non-blocking，但是，如上图所示，整个用户的process其实是一直被block的。只不过process是被select这个函数block，而不是被socket IO给block。

    结论: select的优势在于可以处理多个连接，不适用于单个连接 

 

 

 select监听fd变化的过程分析：

#用户进程创建socket对象，拷贝监听的fd到内核空间，每一个fd会对应一张系统文件表，内核空间的fd响应到数据后，就会发送信号给用户进程数据已到；
#用户进程再发送系统调用，比如（accept）将内核空间的数据copy到用户空间，同时作为接受数据端内核空间的数据清除，这样重新监听时fd再有新的数据又可以响应到了（发送端因为基于TCP协议所以需要收到应答后才会清除）。

    该模型的优点：

#相比其他模型，使用select() 的事件驱动模型只用单线程（进程）执行，占用资源少，不消耗太多 CPU，同时能够为多客户端提供服务。如果试图建立一个简单的事件驱动的服务器程序，这个模型有一定的参考价值。

    该模型的缺点：

#首先select()接口并不是实现“事件驱动”的最好选择。因为当需要探测的句柄值较大时，select()接口本身需要消耗大量时间去轮询各个句柄。
#很多操作系统提供了更为高效的接口，如linux提供了epoll，BSD提供了kqueue，Solaris提供了/dev/poll，…。
#如果需要实现更高效的服务器程序，类似epoll这样的接口更被推荐。遗憾的是不同的操作系统特供的epoll接口有很大差异，
#所以使用类似于epoll的接口实现具有较好跨平台能力的服务器会比较困难。
#其次，该模型将事件探测和事件响应夹杂在一起，一旦事件响应的执行体庞大，则对整个模型是灾难性的。

5|0异步IO(Asynchronous I/O)

Linux下的asynchronous IO其实用得不多，从内核2.6版本才开始引入。先看一下它的流程：

　　用户进程发起read操作之后，立刻就可以开始去做其它的事。而另一方面，从kernel的角度，当它受到一个asynchronous read之后，首先它会立刻返回，所以不会对用户进程产生任何block。然后，kernel会等待数据准备完成，然后将数据拷贝到用户内存，当这一切都完成之后，kernel会给用户进程发送一个signal，告诉它read操作完成了。

6|0IO模型比较分析

到目前为止，已经将四个IO Model都介绍完了。现在回过头来回答最初的那几个问题：blocking和non-blocking的区别在哪，synchronous IO和asynchronous IO的区别在哪。
    先回答最简单的这个：blocking vs non-blocking。前面的介绍中其实已经很明确的说明了这两者的区别。调用blocking IO会一直block住对应的进程直到操作完成，而non-blocking IO在kernel还准备数据的情况下会立刻返回。

    再说明synchronous IO和asynchronous IO的区别之前，需要先给出两者的定义。Stevens给出的定义（其实是POSIX的定义）是这样子的：
    A synchronous I/O operation causes the requesting process to be blocked until that I/O operationcompletes;
    An asynchronous I/O operation does not cause the requesting process to be blocked; 
    两者的区别就在于synchronous IO做”IO operation”的时候会将process阻塞。按照这个定义，四个IO模型可以分为两大类，之前所述的blocking IO，non-blocking IO，IO multiplexing都属于synchronous IO这一类，而 asynchronous I/O后一类 。

    有人可能会说，non-blocking IO并没有被block啊。这里有个非常“狡猾”的地方，定义中所指的”IO operation”是指真实的IO操作，就是例子中的recvfrom这个system call。non-blocking IO在执行recvfrom这个system call的时候，如果kernel的数据没有准备好，这时候不会block进程。但是，当kernel中数据准备好的时候，recvfrom会将数据从kernel拷贝到用户内存中，这个时候进程是被block了，在这段时间内，进程是被block的。而asynchronous IO则不一样，当进程发起IO 操作之后，就直接返回再也不理睬了，直到kernel发送一个信号，告诉进程说IO完成。在这整个过程中，进程完全没有被block。

    各个IO Model的比较如图所示：

　　

　　经过上面的介绍，会发现non-blocking IO和asynchronous IO的区别还是很明显的。在non-blocking IO中，虽然进程大部分时间都不会被block，但是它仍然要求进程去主动的check，并且当数据准备完成以后，也需要进程主动的再次调用recvfrom来将数据拷贝到用户内存。而asynchronous IO则完全不同。它就像是用户进程将整个IO操作交给了他人（kernel）完成，然后他人做完后发信号通知。在此期间，用户进程不需要去检查IO操作的状态，也不需要主动的去拷贝数据。