进程池和线程池

线程池

预先创建好一个数量较为优化的线程组，在需要的时候立刻能够使用，就形成了线程池。就像生产者消费者模型那样，主线程就像生产者一样，他会不断地的向池中提交任务，而并不关心池的内部是如何执行的以及哪一个子线程来执行任务。线程池中的线程就相当于消费者，他会不断地接受任务并将任务分派给空闲的线程去执行。

来看例子。

import threading
import queue
import time
class MyThreadPool:
    def __init__(self,maxSize):
        self.maxSize=maxSize
        self._pool=queue.Queue(maxSize)
        for _ in range(maxSize):
            self._pool.put(threading.Thread)
    def getThread(self):
        return  self._pool.get()
    def addThread(self):
        self._pool.put(threading.Thread)
def run(i,pool):
    print("执行任务",i)
    time.sleep(1)
    pool.addThread()
if __name__ == '__main__':
    pool=MyThreadPool(5)
    for i in range(20):
        t=pool.getThread()
        obj=t(target=run,args=(i,pool))
        obj.start()
    print("活动的子线程：",threading.active_count()-1)

以上代码的性能并不优化，实际设计还需要考虑的更多。

python中自带的池

线程池

from multiprocessing.pool import ThreadPool
import time
def task_one():
    time.sleep(1)
    print("任务一完成！")
def task_two():
    time.sleep(1)
    print("任务二完成！")

pool=ThreadPool(2)
pool.apply_async(task_one)
pool.apply_async(task_two)
print("任务提交完成！")

pool.close()#在join之前必须关闭，不允许再向池中提交任务
pool.join()
print("任务完成！")

进程池

from multiprocessing import Pool
import time
def task_one():
    time.sleep(1)
    print("任务一完成！")
def task_two():
    time.sleep(1)
    print("任务二完成！")

if __name__ == '__main__':
    pool=Pool(2)
    pool.apply_async(task_one)
    pool.apply_async(task_two)
    print("任务提交完成！")
    pool.close()
    pool.join()
    print("任务完成！")

线程池实现并发服务器

from multiprocessing.pool import ThreadPool
import socket

server=socket.socket()
server.bind(('0.0.0.0',9999))
server.listen()

def worker(connection):
    while True:
        recv_data=connection.recv(1024)
        if recv_data:
            print("接收到数据：",recv_data)
            connection.send(recv_data)
        else:
            connection.close()
            break

if __name__ == '__main__':
    pool=ThreadPool(4)
    while True:
        conn,addr=server.accept()
        pool.apply_async(worker,args=(conn,))

import socket
client=socket.socket()
client.connect(('0.0.0.0',9999))
while True:
    data=input("请发送数据：")
    client.send(data.encode())
    print("收到回送数据：",client.recv(1024).decode())

进程池+线程池实现并发服务器

from multiprocessing.pool import ThreadPool
from multiprocessing import Pool
import socket
import os

server=socket.socket()
server.bind(('0.0.0.0',9999))
server.listen()

def worker(connection):
    while True:
        recv_data=connection.recv(1024)
        if recv_data:
            print("接收到数据：",recv_data)
            connection.send(recv_data)
        else:
            connection.close()
            break
def worker_process(server):
    thread_pool=ThreadPool(os.cpu_count()*2)#分配2倍CPU的进程
    while True:
        coon,addr=server.accept()
        thread_pool.apply_async(worker,args=(coon,))

if __name__ == '__main__':
    n=os.cpu_count()
    process_pool=Pool(n)
    for i in range(n):
        process_pool.apply_async(worker_process,args=(server,))
    process_pool.close()
    process_pool.join()

import socket
client=socket.socket()
client.connect(('0.0.0.0',9999))
while True:
    data=input("请发送数据：")
    client.send(data.encode())
    print("接收到数据",client.recv(1024).decode())