基于python的简单HTTP服务器实现（三）

HTTP服务器实现

在基于python的简单HTTP服务器实现（二）中，我们实现了支持session的服务器，实现了基本功能。当考虑服务器在接受多个请求时，如果对每一个请求都开辟一个线程，那么开销是非常巨大的，而且线程的数量无法控制，因此想到使用线程池来解决这个问题。

线程池

线程池的效果如图所示，线程池管理程序会生成固定数量的线程，同时会有一个任务队列，任务发布者往队列中添加任务，然后线程依次在队列中取出任务。使用线程池的设计，所有的任务都是由线程池中固定数量的线程完成，线程数量可控，同时没有反复创建销毁线程的开销。

图片来自网络，侵权删除

python中的线程池

python中线程的使用见PyQt5中异步刷新UI和Python中的多线程总结

基于threadpool

1. threadpool.ThreadPool(5) 生成一个线程池
2. threadpool.makeRequests(func, range(10)) 生成一些任务，这里面func是执行任务的函数，后面是任务的参数，是一个list，每次执行会调用一个
3. task_pool.putRequest(req) 添加任务，将任务扔进线程池，线程池将会执行

import threadpool
import time

def func(value):
    print(value, '\t')
    time.sleep(1)
task_pool = threadpool.ThreadPool(5)
request = threadpool.makeRequests(func, range(10))
for req in request:
    task_pool.putRequest(req)
task_pool.wait()

基于futures

基于submit的方式输出是无序的，基于map的方式输出是有序的

1. futures.ThreadPoolExecutor(max_workers=3) 生成线程池

2. exector.submit(func, i)或exector.map(func, range(10)) 添加任务给线程池

   • submit方式：每次提交一个请求

import time
from concurrent import futures

def func(value):
    print(value)
    time.sleep(1)

with futures.ThreadPoolExecutor(max_workers=3) as exector:
    for i in range(10):
        exector.submit(func, i)

• map方式：每次会在list对象中取一个数据

import time
from concurrent import futures
def func(value):
    print(value)
    time.sleep(1)

with futures.ThreadPoolExecutor(max_workers=3) as exector:
    exector.map(func, range(10))

具体实现

接下来考虑自己手动实现线程池，参考网络

Queue

由于需要使用一个队列来存储任务，在python中有一个Queue容器，同时这个容器是线程安全的，多个线程进行读写时线程安全。

1. put放入数据
2. get读取数据
3. empty是否为空
4. join阻塞调用线程，直到队列中的所有任务被处理掉。
5. task_done()标志之前的任务已经完成

先进先出队列

import queue

q = queue.Queue()
for i in range(5):
    q.put(i)        # 放入数据
while not q.empty():
    print(q.get())  # 读取数据

后进先出队列【栈】

import queue

q = queue.LifoQueue()
for i in range(5):
    q.put(i)
while not q.empty():
    print(q.get())

线程池实现

• 线程池管理
  
  1. 维护一个任务队列，在队列中添加需要执行的函数和参数，也就是处理每一个tcp的函数
  2. 维护一个线程池，里面包含若干线程，从任务队列中获得任务
• 任务线程
  
  1. 从任务队列中获得任务，没有任务时阻塞
  2. 完成任务后需要标识该项任务已经完成

# 每个任务线程
class WorkThread(threading.Thread):
    def __init__(self, work_queue):
        super().__init__()
        self.work_queue = work_queue
        self.daemon = True

    def run(self):
        while True:
            func, args = self.work_queue.get()
            func(*args)
            self.work_queue.task_done()


# 线程池管理
class ThreadPoolManger():
    def __init__(self, thread_number):
        self.thread_number = thread_number
        self.work_queue = queue.Queue()
        for i in range(self.thread_number):     # 生成一些线程来执行任务
            thread = WorkThread(self.work_queue)
            thread.start()

    def add_work(self, func, *args):
        self.work_queue.put((func, args))


def tcp_link(sock, addr):
    print('Accept new connection from %s:%s...' % addr)
    request = sock.recv(1024)
    http_req = HttpRequest()
    http_req.passRequest(request)
    sock.send(http_req.getResponse().encode('utf-8'))
    sock.close()


def start_server():
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.bind(('127.0.0.1', 9999))
    s.listen(10)
    thread_pool = ThreadPoolManger(5)
    print('listen in %s:%d' % ('127.0.0.1', 9999))
    while True:
        sock, addr = s.accept()
        thread_pool.add_work(tcp_link, *(sock, addr))

完整代码见github
如有错误，欢迎指正~