线程进程池、协程、IO模型

一、进程池与线程池

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

在计算机能够承受范围之内最大限度的利用计算机，就要涉及到一个新的概念，线程池和进程池

1.什么是池？

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

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

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

2.线程池和进程池

from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
import time

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

'''
池子中创建的进程/线程创建一次就不会再创建了
至始至终用的都是最初的那几个
这样的话节省了反复开辟进程/线程的资源
'''

def task(n):
    print(n)
    time.sleep(1)
    return n * 5
'''
提交任务的方式
    同步：提交任务之后，原地等待任务的返回结果，期间不做任何事
    异步：提交任务之后，不等待任务的返回结果，直接执行下一行代码
'''
# pool.submit(task,1) # 朝线程池中提交任务 属于异步提交

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,ProcessPoolExecutor
import time
import os

pool = ProcessPoolExecutor(5) # 括号内可以传参数指定线程池内的线程个数，也可以不传，不传默认是当前所在计算机的cpu个数乘5
'''
池子中创建的进程/线程创建一次就不会再创建了
至始至终用的都是最初的那几个
这样的话节省了反复开辟进程/线程的资源
'''

def task(n):
    print(n,os.getpid())
    time.sleep(1)
    return n * 5
'''
提交任务的方式
    同步：提交任务之后，原地等待任务的返回结果，期间不做任何事
    异步：提交任务之后，不等待任务的返回结果，直接执行下一行代码
'''
# pool.submit(task,1) # 朝线程池中提交任务 属于异步提交

if __name__ == '__main__':
    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 ProcessPoolExecutor
import time
import os

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

def task(n):
    print(n,os.getpid())
    time.sleep(1)
    return n * 5

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


if __name__ == '__main__':
    for i in range(20):
        res = pool.submit(task,i).add_done_callback(call_back) # 提交任务的时候 绑定一个回调函数，一旦该任务有结果，立刻执行对应的回调函数

二、协程

　　单线程下实现并发

首先捋一捋所有的‘程’：

1.进程：资源单位

2.线程：执行单位

3.协程：单线程下实现并发，它是程序员们自己发明出来的一个词而已，并不是一个什么概念

　　并发：切换+保存状态，让我们看起来好像就是同时执行的，就可以称之为并发

并发的条件：

　　多道技术：1.空间上的复用，2.时间上的复用

★协程的真面目：

程序员自己通过代码自己检测程序中的IO，一旦遇到IO自己通过代码切换，给操作系感觉是你这个线程没有任何IO

其实就是，欺骗操作系统，让它误认为你这个程序一直没有IO，从而保证程序在运行态和就绪态来回切换，提升代码的运行效率

# 串行执行 0.8540799617767334
import time

def func1():
    for i in range(10000000):
        i+1

def func2():
    for i in range(10000000):
        i+1

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

#基于yield并发执行  1.3952205181121826
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()
print(stop-start)

但是上述的切换+保存不能识别你的IO操作，那么就需要一个能够识别IO的工具，一个新的模块：gevent(需要额外下载)

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

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

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

三、使用gevent实现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()

四、IO模型

　　此处引用：

　　https://www.cnblogs.com/Dominic-Ji/articles/10929396.htm