一、多线程、多进程、协程实现并发web服务器
(1)多线程
import socket
import re
import threading
def service_client(new_socket):
"""为这个客户端返回数据"""
# 1 接收浏览器发送过来的请求,http请求
# GET/HTTP/1.1
# ...
request = new_socket.recv(1024).decode("utf-8")
# print(">>>" * 50)
# print(request)
request_lines = request.splitlines()
print("")
print(">>>" * 50)
print(request_lines)
# GET/index.html HTTP/1.1
file_name = ""
ret = re.match(r"[^/]+(/[^ ]*)", request_lines[0])
if ret:
file_name = ret.group(1)
# print("*" * 50, file_name)
if file_name == "/":
file_name = "/index.html"
# 2 返回http格式的数据,给浏览器
try:
f = open("./html" + file_name, "rb")
except:
response = "HTTP/1.1 404 NOT FOUND\r\n"
response += "\r\n"
response += "--file not found--"
new_socket.send(response.encode("utf-8"))
# 关闭套接字
new_socket.close()
else:
html_content = f.read()
f.close()
# 2.1 准备发送给浏览器的数据---header
response = "HTTP/1.1 200 OK\r\n"
response += "\r\n"
# 2.2 准备发送给浏览器的数据---body
# response += "hahaha"
# 将response header发送给浏览器
new_socket.send(response.encode("utf-8"))
new_socket.send(html_content)
def main():
"""用来完成整体的控制"""
# 1 创建套接字
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 2 绑定
tcp_server_socket.bind(("", 7890))
# 3 变为监听套接字
tcp_server_socket.listen(128)
while True:
# 4 等待新客户端的链接
new_socket, client_addr = tcp_server_socket.accept()
# 5 为这个客户端服务
p = threading.Thread(target=service_client, args=(new_socket, ))
p.start()
# # 多任务创建了一个新的socket
# new_socket.close()
# 关闭监听套接字
tcp_server_socket.close()
if __name__ == '__main__':
main()
(2)多线程
import socket
import re
import multiprocessing
def service_client(new_socket):
"""为这个客户端返回数据"""
# 1 接收浏览器发送过来的请求,http请求
# GET/HTTP/1.1
# ...
request = new_socket.recv(1024).decode("utf-8")
# print(">>>" * 50)
# print(request)
request_lines = request.splitlines()
print("")
print(">>>" * 50)
print(request_lines)
# GET/index.html HTTP/1.1
file_name = ""
ret = re.match(r"[^/]+(/[^ ]*)", request_lines[0])
if ret:
file_name = ret.group(1)
# print("*" * 50, file_name)
if file_name == "/":
file_name = "/index.html"
# 2 返回http格式的数据,给浏览器
try:
f = open("./html" + file_name, "rb")
except:
response = "HTTP/1.1 404 NOT FOUND\r\n"
response += "\r\n"
response += "--file not found--"
new_socket.send(response.encode("utf-8"))
# 关闭套接字
new_socket.close()
else:
html_content = f.read()
f.close()
# 2.1 准备发送给浏览器的数据---header
response = "HTTP/1.1 200 OK\r\n"
response += "\r\n"
# 2.2 准备发送给浏览器的数据---body
# response += "hahaha"
# 将response header发送给浏览器
new_socket.send(response.encode("utf-8"))
new_socket.send(html_content)
def main():
"""用来完成整体的控制"""
# 1 创建套接字
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 2 绑定
tcp_server_socket.bind(("", 7890))
# 3 变为监听套接字
tcp_server_socket.listen(128)
while True:
# 4 等待新客户端的链接
new_socket, client_addr = tcp_server_socket.accept()
# 5 为这个客户端服务
p = multiprocessing.Process(target=service_client, args=(new_socket, ))
p.start()
# 多任务创建了一个新的socket
new_socket.close()
# 关闭监听套接字
tcp_server_socket.close()
if __name__ == '__main__':
main()
(3)协程
import socket
import re
import gevent
from gevent import monkey
monkey.patch_all()
def service_client(new_socket):
"""为这个客户端返回数据"""
# 1 接收浏览器发送过来的请求,http请求
# GET/HTTP/1.1
# ...
request = new_socket.recv(1024).decode("utf-8")
# print(">>>" * 50)
# print(request)
request_lines = request.splitlines()
print("")
print(">>>" * 50)
print(request_lines)
# GET/index.html HTTP/1.1
file_name = ""
ret = re.match(r"[^/]+(/[^ ]*)", request_lines[0])
if ret:
file_name = ret.group(1)
# print("*" * 50, file_name)
if file_name == "/":
file_name = "/index.html"
# 2 返回http格式的数据,给浏览器
try:
f = open("./html" + file_name, "rb")
except:
response = "HTTP/1.1 404 NOT FOUND\r\n"
response += "\r\n"
response += "--file not found--"
new_socket.send(response.encode("utf-8"))
# 关闭套接字
new_socket.close()
else:
html_content = f.read()
f.close()
# 2.1 准备发送给浏览器的数据---header
response = "HTTP/1.1 200 OK\r\n"
response += "\r\n"
# 2.2 准备发送给浏览器的数据---body
# response += "hahaha"
# 将response header发送给浏览器
new_socket.send(response.encode("utf-8"))
new_socket.send(html_content)
def main():
"""用来完成整体的控制"""
# 1 创建套接字
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 2 绑定
tcp_server_socket.bind(("", 7890))
# 3 变为监听套接字
tcp_server_socket.listen(128)
while True:
# 4 等待新客户端的链接
new_socket, client_addr = tcp_server_socket.accept()
# 5 为这个客户端服务
gevent.spawn(service_client, new_socket)
# # 多任务创建了一个新的socket
# new_socket.close()
# 关闭监听套接字
tcp_server_socket.close()
if __name__ == '__main__':
main()
二、单进程、单线程、非堵塞
import socket
import re
def service_client(new_socket, request):
"""为这个客户端返回数据"""
# 1. 接收浏览器发送过来的请求 ,即http请求
# GET / HTTP/1.1
# .....
# request = new_socket.recv(1024).decode("utf-8")
# print(">>>"*50)
# print(request)
request_lines = request.splitlines()
print("")
print(">" * 20)
print(request_lines)
# GET /index.html HTTP/1.1
# get post put del
file_name = ""
ret = re.match(r"[^/]+(/[^ ]*)", request_lines[0])
if ret:
file_name = ret.group(1)
# print("*"*50, file_name)
if file_name == "/":
file_name = "/index.html"
# 2. 返回http格式的数据,给浏览器
try:
f = open("./html" + file_name, "rb")
except:
response = "HTTP/1.1 404 NOT FOUND\r\n"
response += "\r\n"
response += "------file not found-----"
new_socket.send(response.encode("utf-8"))
else:
html_content = f.read()
f.close()
response_body = html_content
response_header = "HTTP/1.1 200 OK\r\n"
response_header += "Content-Length:%d\r\n" % len(response_body)
response_header += "\r\n"
response = response_header.encode("utf-8") + response_body
new_socket.send(response)
def main():
"""用来完成整体的控制"""
# 1. 创建套接字
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# 2. 绑定
tcp_server_socket.bind(("", 7890))
# 3. 变为监听套接字
tcp_server_socket.listen(128)
tcp_server_socket.setblocking(False) # 将套接字变为非堵塞
client_socket_list = list()
while True:
# 4. 等待新客户端的链接
try:
new_socket, client_addr = tcp_server_socket.accept()
except Exception as ret:
pass
else:
new_socket.setblocking(False)
client_socket_list.append(new_socket)
for client_socket in client_socket_list:
try:
recv_data = client_socket.recv(1024).decode("utf-8")
except Exception as ret:
pass
else:
if recv_data:
service_client(client_socket, recv_data)
else:
client_socket.close()
client_socket_list.remove(client_socket)
# 关闭监听套接字
tcp_server_socket.close()
if __name__ == "__main__":
main()
三、I/O复用(epoll)
import socket
import re
import select
def service_client(new_socket, request):
"""为这个客户端返回数据"""
# 1. 接收浏览器发送过来的请求 ,即http请求
# GET / HTTP/1.1
# .....
# request = new_socket.recv(1024).decode("utf-8")
# print(">>>"*50)
# print(request)
request_lines = request.splitlines()
print("")
print(">" * 20)
print(request_lines)
# GET /index.html HTTP/1.1
# get post put del
file_name = ""
ret = re.match(r"[^/]+(/[^ ]*)", request_lines[0])
if ret:
file_name = ret.group(1)
# print("*"*50, file_name)
if file_name == "/":
file_name = "/index.html"
# 2. 返回http格式的数据,给浏览器
try:
f = open("./html" + file_name, "rb")
except:
response = "HTTP/1.1 404 NOT FOUND\r\n"
response += "\r\n"
response += "------file not found-----"
new_socket.send(response.encode("utf-8"))
else:
html_content = f.read()
f.close()
response_body = html_content
response_header = "HTTP/1.1 200 OK\r\n"
response_header += "Content-Length:%d\r\n" % len(response_body)
response_header += "\r\n"
response = response_header.encode("utf-8") + response_body
new_socket.send(response)
def main():
"""用来完成整体的控制"""
# 1. 创建套接字
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# 2. 绑定
tcp_server_socket.bind(("127.0.0.1", 7890))
# 3. 变为监听套接字
tcp_server_socket.listen(128)
tcp_server_socket.setblocking(False) # 将套接字变为非堵塞
# 创建一个epoll对象
epl = select.epoll()
# 将监听套接字对应的fd注册到epoll中
epl.register(tcp_server_socket.fileno(), select.EPOLLIN)
fd_event_dict = dict()
while True:
fd_event_list = epl.poll() # 默认会堵塞,直到 os监测到数据到来 通过事件通知方式 告诉这个程序,此时才会解堵塞
# [(fd, event), (套接字对应的文件描述符, 这个文件描述符到底是什么事件 例如 可以调用recv接收等)]
for fd, event in fd_event_list:
# 等待新客户端的链接
if fd == tcp_server_socket.fileno():
new_socket, client_addr = tcp_server_socket.accept()
epl.register(new_socket.fileno(), select.EPOLLIN)
fd_event_dict[new_socket.fileno()] = new_socket
elif event == select.EPOLLIN:
# 判断已经链接的客户端是否有数据发送过来
recv_data = fd_event_dict[fd].recv(1024).decode("utf-8")
if recv_data:
service_client(fd_event_dict[fd], recv_data)
else:
fd_event_dict[fd].close()
epl.unregister(fd)
del fd_event_dict[fd]
# 关闭监听套接字
tcp_server_socket.close()
if __name__ == "__main__":
main()