高级编程：并发池

目录

一、可重复利用线程

二、线程池的实现

三、内置池

四、使用内置池来实现并发服务器

五、补充

---

一、可重复利用线程

       定义：一条线程 可以重复使用，或者说可以跑同一个任务。 

     定义：线程池可以看做一个池子，那么这个池子里面有多条可以重复利用的的线程

队列计数器：队列自己内部有一个计数器，当计数为0时，join不会阻塞，否则就会阻塞。

join的用法：判断这个队列是否处于堵塞状态。

task_done：是给计数器减一的一个操作。

>>> import queue
>>> q = queue.Queue(4)
>>> q.join()
>>> q.put('a')
>>> q.join()

 此时因为列表里面有数据  ‘a’ ，join就会堵塞。

解决堵塞：

import queue
q = queue.Queue(4)
q.put('a')
q.task_done()
q.join()

此时添加 task_done 就可以运行，不会堵塞。

---

线程的重复利用：利用生产者与消费者模型，实现线程的重复利用。

利用生产者与消费者模型，实现线程的重复利用.
主进程可以看成生产者，主要产生任务
线程作为消费者，主要是处理任务 

可重复利用线程实现的原理：

---

二、线程池的实现

池是怎么处理数据的：可以分为一下七个步骤：

1.定义init的方法

2.提交任务方法

        2.1一个接受元祖，一个接受字典，要提交的任务一、任务二要用一个函数func提交

        2.2向队列里提交任务，此时向队列里添加三个参数，把这三个参数最为一个容器，进行传递。

3.处理任务方法

        3.1利用元祖拆包，利用三个不同的变量接受元祖数据，从队列里面获取任务和参数

        3.2执行任务

4.如何保证队列为空

        4.1.当计数器为0时，他就不阻塞，要想不阻塞，就是处理一条数据后，将数据和队列做计算器减一的操作

        4.2 队列计数器减一操作

5.处理那些数据呢？给两个任务

6.创建一个线程

        6.1创建线程池子：线程池里面同时有多条可以同时重复使用的线程

import time
import queue
import threading

class Mypool:
    def __init__(self,n):      #定义init的方法
        self.queue = queue.Queue(4)
        for i in range(n): #初始化时候直接开启Ｎ条可重复利用的线程
            threading.Thread(target=self.func,daemon=True).start()  ##保持多条线程启动状态

    #2.处理任务方法
    def func(self):  #func 不听取处理我们的任务
        while 1:  #让他不停地接受并执行这个任务
            func,args,kwargs = self.queue.get()  #利用元祖拆包，利用三个不同的变量接受元祖数据，从队列里面获取任务和参数
            func(*args,**kwargs) #执行任务
            self.queue.task_done()  #5.队列计数器减一操作
    #1.提交任务方法
    def submit_task(self,func,args=(),kwargs={}):  #1.1一个接受元祖，一个接受字典，要提交的任务一、任务二要用一个函数提交
        self.queue.put((func,args,kwargs))#1.2向队列里提交任务，此时向队列里添加三个参数，把这三个参数最为一个容器，进行传递。

    # 3.如何保证队列为空
    def join(self):
        self.queue.join()  # 4.当计数器为0时，他就不阻塞，要想不阻塞，就是处理一条数据后，将数据和队列做计算器减一的操作



#6.处理那些数据呢？给两个任务
def func1():
    time.sleep(2)
    print('任务一完成')

def func2(*args,**kwargs):
    time.sleep(2)
    print('任务二完成',args,kwargs)

#7.创建一个线程
if __name__ == '__main__':
    mt = Mypool(4) #4的意思是：线程池里面同时有两条可以同时重复使用的线程
    mt.submit_task(func1)
    mt.submit_task(func2,args=(1,2,3),kwargs={'q':1,'w':2})

    mt.submit_task(func1)
    mt.submit_task(func2, args=(1, 2, 3), kwargs={'q': 1, 'w': 2})

    mt.submit_task(func1)
    mt.submit_task(func2, args=(1, 2, 3), kwargs={'q': 1, 'w': 2})
    mt.join()

---

三、内置池

        概念：就是Python内置的池子，我们直接拿过来使用就好。

        线程池：导入：from multiprocessing.pool import ThreadPool

        进程池：导入：from multiprocessing import Poot

   然而，实际开发当中只需要使用内置池就可以：

import time
from multiprocessing.pool import ThreadPool  # 导入内置线程池
from multiprocessing.pool import Pool   # 导入内置进程池

def func1():
    time.sleep(2)
    print("任务一完成")


def func2(*args, **kwargs):
    time.sleep(2)
    print("任务二完成", args, kwargs)

if __name__ == '__main__':
        t1 = Pool(3)  #创建线程池子：线程池里面同时有3条可以同时重复使用的线程
        t1.apply_async(func1)  #向线程池提交任务
        t1.apply_async(func2,args=(1,2,'a'),kwds={'q':1,'w':2})

        t1.apply_async(func1)  #向线程池提交任务
        t1.apply_async(func2,args=(1,2,3),kwds={'q':1,'w':2})

        t1.apply_async(func1)  #向线程池提交任务
        t1.apply_async(func2,args=(1,2,3),kwds={'q':1,'w':2})
        t1.close()  # 停止提交任务
        t1.join()   # 等待现有任务执行完毕

---

四、使用内置池来实现并发服务器

服务端：

import socket
from multiprocessing.pool import ThreadPool
from multiprocessing import Pool, cpu_count

# n = cpu_count()  # 获取系统核心数
# print(n)
server = socket.socket()
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server.bind(('127.0.0.1', 9000))
server.listen(1000)


def socket_recv(conn):
    while True:
        recv_data = conn.recv(1024)
        if recv_data:
            print(recv_data)
            conn.send(recv_data)
        else:
            conn.close()
            break


def accpet_rpocess(server):
    tp = ThreadPool(cpu_count() * 2)  # 线程池 通常线程可以分配进程核心数的2倍
    while True:
        conn, addr = server.accept()
        tp.apply_async(socket_recv, args=(conn,))


if __name__ == '__main__':
    n = cpu_count()  # 获取cpu核心数
    pool = Pool(n)  # 开启进程池
    pool.apply_async(accpet_rpocess, kwds={'server':server})
    pool.close()
    pool.join()

客户端：

import socket

client = socket.socket()
client.connect(('127.0.0.1', 9000))
for i in range(100000):
    client.send(b'ayan')
    print(client.recv(1024))

五、补充

在进程池里面，以字典的形式进行提交就是kwgs

在线程池里面，以字典的形式进行提交就是kwargs

        再次感谢阿言老师的细心指导。

青春因磨砺而出彩，人生因奋斗而升华！