python之线程池和进程池

线程池和进程池

一、池的概念

• 池是用来保证计算机硬件安全的情况下最大限度的利用计算机
• 它降低了程序的运行效率但是保证了计算机硬件的安全从而让你写的程序能够正常运行

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

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

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

二、线程池

基本使用方式：

from concurrent.futures import ThreadPoolExecutor
import time

# 括号内可以传数字，默认会开启cpu个数5倍的线程，传的数字是多少，线程池里面就有几个线程
pool = ThreadPoolExecutor(4)


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


# pool.submit(task, 1) #朝池子中提交任务，异步提交
# print('主')
 
t_list = []  #不合理
for i in range(10):
    res = pool.submit(task, i)  # res -----> <Future at 0x16b06908cc8 state=pending>
    #print(res.result())  # 同步提交
    t_list.append(res)

pool.shutdown()
for i in t_list:
    print('>>>>>>>>>>',i.result())
'''
    现在是submit一次就得等待一次
    为了这5个线程同时启动，可以定义个列表，把线程append到t_list中
    然后遍历t_list，再result
    等待线程池中的任务执行完毕之后再往下执行：pool.shutdown，关闭线程池  等待线程池中所有的任务运行完毕
'''

'''
    调用了result后：
        程序有并发变成了串行
    那么任务的为什么打印的是None？
        res.result() 拿到的就是异步提交的任务(task函数)的返回结果,当我们给task函数return一个返回值时，node变成函数task的返回值
'''

三、进程池

import os
from concurrent.futures import ProcessPoolExecutor
import time

# 括号内可以传数字，默认会开启你cpu有几个核就开几个，不会超标
pool = ProcessPoolExecutor(5)


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


# pool.submit(task, 1) #朝池子中提交任务，异步提交
# print('主')

def call_back(n):
    #print(n)
    print('call_back>>>>>>>>>>>：',n.result())


if __name__ == '__main__':
    t_list = []
    for i in range(10):
        # res = pool.submit(task, i)  # res -----> <Future at 0x16b06908cc8 state=pending>
        res = pool.submit(task, i).add_done_callback(call_back)  #<Future at 0x1b2a6a325c8 state=finished returned int>
        # print(res.result())  # 同步提交
        #t_list.append(res)

    '''
        现在是submit一次就得等待一次
        为了这5个线程同时启动，可以定义个列表，把线程append到t_list中
        然后遍历t_list，再result
        等待线程池中的任务执行完毕之后再往下执行：pool.shutdown，关闭线程池  等待线程池中所有的任务运行完毕
    '''
    # pool.shutdown()
    # for i in t_list:
    #     print('>>>>>>>>>>', i.result())
'''
    现在是submit一次就得等待一次
    为了这5个线程同时启动，可以定义个列表，把线程append到t_list中
    然后遍历t_list，再result
    等待线程池中的任务执行完毕之后再往下执行：pool.shutdown，关闭线程池  等待线程池中所有的任务运行完毕
'''

'''
    调用了result后：
        程序有并发变成了串行
    那么任务的为什么打印的是None？
        res.result() 拿到的就是异步提交的任务(task函数)的返回结果,当我们给task函数return一个返回值时，node变成函数task的返回值
'''

总结

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
pool = ProcessPoolExecutor(5)
pool.submit(task, i).add_done_callback(call_back)

四、协程

'''
进程:资源单位
线程:执行单位
协程:这个概念完全是程序员自己意淫出来的 根本不存在
		单线程下实现并发
		我们程序员自己再代码层面上检测我们所有的IO操作
		一旦遇到IO了 我们在代码级别完成切换
		这样给CPU的感觉是你这个程序一直在运行 没有IO
		从而提升程序的运行效率
'''

五、gevent模块(了解)

安装

pip3 install gevent -i http://mirrors.aliyun.com/pypi/simple/

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

"""
gevent模块本身无法检测常见的一些io操作
在使用的时候需要你额外的导入一句话
from gevent import monkey
monkey.patch_all()
又由于上面的两句话在使用gevent模块的时候是肯定要导入的
所以还支持简写
from gevent import monkey;monkey.patch_all()
"""


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


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

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


start_time = time.time()
g1 = spawn(heng)  #把监管的函数名放进去就行，然后得join
g2 = spawn(ha)
g3 = spawn(heiheihei)
g1.join()
g2.join()  # 等待被检测的任务执行完毕 再往后继续执行
g3.join()
# heng()
# ha()
# print(time.time() - start_time)  # 5.005702018737793
print(time.time() - start_time)  # 3.004199981689453   5.005439043045044

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

# 服务端
from gevent import monkey;monkey.patch_all()
import socket
from gevent import spawn


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


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


if __name__ == '__main__':
    g1 = spawn(server, '127.0.0.1', 8080)
    g1.join()

    
# 客户端
from threading import Thread, current_thread
import socket


def x_client():
    client = socket.socket()
    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()

总结

"""
理想状态:
	我们可以通过
	多进程下面开设多线程
	多线程下面再开设协程序
	从而使我们的程序执行效率提升
"""