进程池和线程池、协程、单线程实现并发

进程池与线程池
开进程开线程都需要消耗资源，只不过两者比较的情况线程消耗的资源比较少
在计算机能够承受范围之内最大限度的利用计算机
什么是池？
在保证计算机硬件安全的情况下最大限度的利用计算机
池其实是降低了程序的运行效率但是保证了计算机硬件的安全
(硬件的发展跟不上软件的速度)

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

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


def task(n):
    print(n, os.getpid())  # 查看当前进程号
    time.sleep(2)
    return n**2


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


"""
提交任务的方式
    同步：提交任务之后 原地等待任务的返回结果 期间不做任何事
    异步：提交任务之后 不等待任务的返回结果(异步的结果怎么拿？？？) 直接执行下一行代码
"""

# pool.submit(task,1)  # 朝线程池中提交任务    异步提交
# print('主')
"""
异步回调机制:当异步提交的任务有返回结果之后，会自动触发回调函数的执行

"""
if __name__ == '__main__':

    t_list = []
    for i in range(20):
        res = pool.submit(task, i).add_done_callback(call_back)  # 提交任务的时候 绑定一个回调函数 一旦该任务有结果 立刻执行对于的回调函数
        # print(res.result())  # 原地等待任务的返回结果
        t_list.append(res)

    # pool.shutdown()  # 关闭池子 等待池子中所有的任务执行完毕之后 才会往下运行代码
    # for p in t_list:
    #     print('>>>:',p.result())

View Code

协程

进程：资源单位
线程：执行单位
协程：单线程下实现并发

并发
切换+保存状态
ps:看起来像同时执行的就可以称之为并发

协程:完全是程序员自己意淫出来的名词
单线程下实现并发

并发的条件？
多道技术
空间上的复用
时间上的复用
切换+保存状态

程序员自己通过代码自己检测程序中的IO
一旦遇到IO自己通过代码切换
给操作系统的感觉是你这个线程没有任何的IO
ps:欺骗操作系统让它误认为你这个程序一直没有IO
从而保证程序在运行态和就绪态来回切换
提升代码的运行效率
切换+保存状态就一定能够提升效率吗？？？
当你的任务是iO密集型的情况下提升效率
如果你的任务是计算密集型的降低效率
yield 保存上一次的结果
多进程下开多线程
多线程下再开协程

"""
需要找到一个能够识别IO的一个工具
gevent模块
"""
from gevent import monkey;monkey.patch_all()  # 由于该模块经常被使用 所以建议写成一行
from gevent import spawn
import time
"""
注意gevent模块没办法自动识别time.sleep等io情况
需要你手动再配置一个参数
"""


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会检测所有的任务
g3 = spawn(heiheihei)
g1.join()
g2.join()
g3.join()
# heng()
# ha()
print(time.time() - start)

View Code

单线程实现并发：

服务端：

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()

View Code

客户端:

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()

View Code