进程池/线程池与协程

一 进程池与线程池

1、什么是池？

​ 池是用来保证计算机硬件安全的情况下最大限度的利用计算机

​ 它降低了程序的运行，但是保证了计算机硬件的安全，从而让你写的程序能够正常的运行

无论是开设进程也好还是开设线程也好 是不是都需要消耗资源
只不过开设线程的消耗比开设进程的稍微小一点而已

我们是不可能做到无限制的开设进程和线程的 因为计算机硬件的资源更不上！！！
硬件的开发速度远远赶不上软件呐

我们的宗旨应该是在保证计算机硬件能够正常工作的情况下最大限度的利用它

基本使用

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
import time
import os


# pool = ThreadPoolExecutor(5)  # 池子里面固定只有五个线程
# 括号内可以传数字 不传的话默认会开设当前计算机cpu个数五倍的线程
pool = ProcessPoolExecutor(5)
# 括号内可以传数字 不传的话默认会开设当前计算机cpu个数进程
"""
池子造出来之后 里面会固定存在五个线程
这个五个线程不会出现重复创建和销毁的过程
池子造出来之后 里面会固定的几个进程
这个几个进程不会出现重复创建和销毁的过程

池子的使用非常的简单
你只需要将需要做的任务往池子中提交即可 自动会有人来服务你
"""


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

def call_back(n):
    print('call_back>>>:',n.result())
"""
任务的提交方式
    同步:提交任务之后原地等待任务的返回结果 期间不做任何事
    异步:提交任务之后不等待任务的返回结果 执行继续往下执行
        返回结果如何获取？？？
        异步提交任务的返回结果 应该通过回调机制来获取
        回调机制
            就相当于给每个异步任务绑定了一个定时炸弹
            一旦该任务有结果立刻触发爆炸
"""
if __name__ == '__main__':
    # pool.submit(task, 1)  # 朝池子中提交任务  异步提交
    # print('主')
    t_list = []
    for i in range(20):  # 朝池子中提交20个任务
        # res = pool.submit(task, i)  # <Future at 0x100f97b38 state=running>
        res = pool.submit(task, i).add_done_callback(call_back)
        # print(res.result())  # result方法   同步提交
        # t_list.append(res)
    # 等待线程池中所有的任务执行完毕之后再继续往下执行
    # pool.shutdown()  # 关闭线程池  等待线程池中所有的任务运行完毕
    # for t in t_list:
    #     print('>>>:',t.result())  # 肯定是有序的
"""
程序有并发变成了串行
任务的为什么打印的是None
res.result() 拿到的就是异步提交的任务的返回结果
"""

总结(掌握)

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor 
pool = ProcessPoolExcecutor(5)
 # res = pool.submit(task, i)  # <Future at 0x100f97b38 state=running>，future对象
pool = submit(task, i).add_done_callback(call_back) #任务结束后会立即触发，通过回调机制拿到返回的结果

二 协程

进程：资源单位

线程：执行单位

多道技术：

​ 切换 + 保存状态

​ cpu 两种切换

​ 1、程序遇到 IO

​ 2、程序长时间占用

协程

协程：是单线程下的并发，又称微线程，纤程。协程是一种用户态的轻量级线程，即

协程是由用户程序自己控制调度的

强调：

1、python的线程属于内核级别的，即有操作系统控制调度
		如：遇到IO操作或者程序执行过长
2、单线程内开启协程，一旦遇到io，就会从应用程序级别(而非操作系统)控制切换，以此来提升效率（非 IO操作时的切换与效率无关）

对比：

​ 1、操作系统控制线程的切换

​ 2、用户在单线程内控制协程的切换

协程这个概念完全是程序员自己造出来的(计算机是不知道的)，根本不存在

​			单线程下实现并发

​			我们程序员在代码层面上检测我们所有的 IO 操作

​			一旦遇到 IO了  我们在代码级别完成切换

​			这样给 cpu 的感觉是你这个程序一直运行   没有 IO操作

​ 作用：

​ 1、单线程内实现并发的效果，最大限度地利用 cpu

​ 2、遇到 IO 时实现代码级别切换，给 cpu 感觉没有 IO 操作，从而提升程序的运行效率

协程的优缺点

​ 优点：

​ 1、协程的切换开销小，属于程序内的切换，操作系统完全感知不到，因而更加轻量级

​ 2、单线程内就可以实现并发的效果，最大限度地利用 cpu

​ 缺点：

​ 1、协程的本质是单线程下，无法利用多核

​ 2、协程指的是单个线程，因而一旦协程出现阻塞，将会阻塞整个线程

代码如何做到：切换 + 保存状态

切换：

​ 当数据结构为计算密集型时，切换降低运行效率

​ IO切换可以提运行翔效率

​ 没有不是IO操作时，切换会降低运行效率

保存状态

​ 保存上一次我执行的状态 下一次来接着上一次的操作继续往后执行

​ 有：yield

验证切换是否就一定可以提升运行效率

import time

# 串行执行计算密集型的任务   1.2372429370880127
def func1():
    for i in range(10000000):
        i + 1

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

start_time = time.time()
func1()
func2()
print(time.time() - start_time)

# 切换 + yield  2.1247239112854004
import time


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


def func2():
    g = func1()  # 先初始化出生成器
    for i in range(10000000):
        i + 1
        next(g)

start_time = time.time()
func2()
print(time.time() - start_time)

三 Gevent库(了解)

1、grevent 库了解

​ 当一个协程遇到 IO 操作时，可以自动切换到其他协程，如何检测 IO 操作，以及实现切换就用到了 gevent 模块

​ Gevent模块是一个第三方库，可以轻松通过 gevent 实现并发同步或一部编程，在 gevent中用到的主要模式是Greentlet，它是以 扩展模块形式接入 Python的轻量级协程，Greentlet全部运行在主程序操作系统的内部，但它们被协作式地调度。

注：

​ gevent模块本事是无法检测常见的一些 IO 操作的，在使用的时候需要额外导入：

from gevent import monkey
monkey.patch_all()

#由于上面的两句话在使用gevent 模块的时候是肯定需要导入的，所以支持简写为：
from grevent import mokey;mokey.patch_all()
'''
必须放在被打补丁者的前面
'''

2、具体用法

from gevent import monkey;monkey.patch_all() #识别IO,必须放在被打补丁者之前
import time
from gevent import spawn
import threading


def heng():
    #查看假线程名（协程）
    print(threading.current_thread().getName()) #DummyThread-1
    print('哼')
    time.sleep(2)
    print('哼')

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


def heiheihei():
    print(threading.current_thread().getName())
    print('heiheihei')
    time.sleep(5)
    print('heiheihei')



start_time = time.time()
g1 = spawn(heng) #生成协程对象
g2 = spawn(ha)
g3 = spawn(heiheihei)
g1.join()
g2.join()  # 等待被检测的任务执行完毕 再往后继续执行
g3.join()

#总时间可以看出此时协程是异步提交
print(time.time() - start_time)  # 5.000796318054199


#结果展示
'''
DummyThread-1
哼
DummyThread-2
哈
DummyThread-3
heiheihei
哼
哈
heiheihei
5.000796318054199

Process finished with exit code 0

'''

3、协程实现 TCP 服务端的并发

# 服务端
from gevent import monkey;monkey.patch_all() #识别IO，必须放在被打补丁者之前
import socket
from gevent import spawn


#如果不想用money.patch_all()打补丁,可以用gevent自带的socket
# from gevent import socket
# s=socket.socket()


#连接循环
def server(ip, port):
    server = socket.socket()
    server.bind((ip, port))
    server.listen(5)
    while True:
        conn, addr = server.accept()
        spawn(communication, conn)

#通信循环
def communication(conn):
    while True:
        try:
            data = conn.recv(1024)
            if len(data) == 0: break
            conn.send(data.upper())
        except ConnectionResetError as e:
            print(e)
            break
    conn.close()



if __name__ == '__main__':
   server('127.0.0.1', 8081)
    
# 多线程并发客户端
from threading import Thread, current_thread
import socket


def x_client():
    client = socket.socket() ##套接字对象一定要加到函数内，即局部名称空间内，r如果放在函数外则被所有线程共享，则大家公用一个套接字对象，那么所有线程的客户端端口永远一样了
    client.connect(('127.0.0.1',8080)) 
    n = 0
    while True:
        msg = '%s say hello %s'%(current_thread().name,n)
        n += 1
        client.send(msg.encode('utf-8'))
        data = client.recv(1024)
        print(data.decode('utf-8'))


if __name__ == '__main__':
    for i in range(500):
        t = Thread(target=x_client)
        t.start()

总结：

​ 理想状态：

​ 我们可以通过，多进程下面开设多线程，多线程下面再开设协程

​ 目的：从而使我们的程序执行效率提升