二、显示固定的页面
2.1、服务器端代码（TCP）
import socket
def server_client(new_socket):
"""为这个客户端返回数据"""
# # 组织相应 头信息(header)
# 1.接收浏览器发送过来的请求，即 http请求
# GET / HTTP/1.1
# ....
request = new_socket.recv(1024)
print(request)
# 2.返回http格式的数据，给浏览器
# 2.1、准备发送给浏览器的数据---header
response = "HTTP/1.1 200 OK\r\n" # 200表示找到这个资源
response += "\r\n" # 用一个空的行与body进行隔开
# 2.2、准备发送给浏览器的数据 ---body
response += "
您好吗？/h4>"
new_socket.send(response.encode("utf-8"))
# 3.关闭套接字
new_socket.close()
def main():
"""用来完成整体的控制"""
# 1.创建套接字
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 2.绑定
tcp_server_socket.bind(("192.168.3.6", 7280))
# 3.变为监听套接字
tcp_server_socket.listen(128)
while True:
# 4.等待客户端的链接
new_socket, client_addr = tcp_server_socket.accept()
# 5.为这个客户端服务
server_client(new_socket)
# 6.关闭监听的套接字
tcp_server_socket.close()
if __name__ == '__main__':
main()
四、返回浏览器需要的界面分析 以及 并发服务器
4.1、服务器端代码
import socket
import re
def server_client(new_socket):
"""为这个客户端返回数据"""
# # 组织相应 头信息(header)
# 1.接收浏览器发送过来的请求，即 http请求
# GET / HTTP/1.1
# ....
request = new_socket.recv(1024).decode("utf-8")
# 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("file_name=%s" % file_name)
print("*"*50,file_name)
if file_name == "/":
file_name = "/index.html"
# 2.返回http格式的数据，给浏览器
# 2.1、准备发送给浏览器的数据---header
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:
print("-----------OK------------")
html_content = f.read()
f.close()
response = "HTTP/1.1 200 OK\r\n" # 200表示找到这个资源
response += "\r\n" # 用一个空的行与body进行隔开
# 2.2、准备发送给浏览器的数据 ---body
# 将response的header发送给浏览器
new_socket.send(response.encode("utf-8"))
# 将response的 body 发送给浏览器
new_socket.send(html_content)
# 3.关闭套接字
new_socket.close()
def main():
"""用来完成整体的控制"""
# 1.创建套接字
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 2.绑定
tcp_server_socket.bind(("192.168.3.6", 7590))
# 3.变为监听套接字
tcp_server_socket.listen(128)
while True:
# 4.等待客户端的链接
new_socket, client_addr = tcp_server_socket.accept()
# 5.为这个客户端服务
server_client(new_socket)
# 6.关闭监听的套接字
tcp_server_socket.close()
if __name__ == '__main__':
main()
分析一下上面代码中的正则：ret = re.match(r"[^/]+(/[^ ]*)",request_lines[0])
”^”这个字符是在中括号 []中被使用的话就是表示字符类的否定，如果不是的话就是表示限定开头。我这里说的是直接在[]中使用，不包括嵌套使用。
其实也就是说 [] 代表的是一个字符集，^ 只有在字符集中才是反向字符集的意思。
[^/]+(/[^ ]*： 意思是 : [^/]:除了 / 以外，+：至少一个字符，/[^ ]*：表示除了空格，也就是到空格就不匹配了，*：表示匹配前一个字符出现0次或者无限次，即可有可无
4.2、多进程实现http服务器
import socket
import multiprocessing
import re
def server_client(new_socket):
"""为这个客户端返回数据"""
# # 组织相应 头信息(header)
# 1.接收浏览器发送过来的请求，即 http请求
# GET / HTTP/1.1
# ....
request = new_socket.recv(1024).decode("utf-8")
# 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("file_name=%s" % file_name)
print("*"*50,file_name)
if file_name == "/":
file_name = "/index.html"
# 2.返回http格式的数据，给浏览器
# 2.1、准备发送给浏览器的数据---header
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:
print("-----------OK------------")
html_content = f.read()
f.close()
response = "HTTP/1.1 200 OK\r\n" # 200表示找到这个资源
response += "\r\n" # 用一个空的行与body进行隔开
# 2.2、准备发送给浏览器的数据 ---body
# 将response的header发送给浏览器
new_socket.send(response.encode("utf-8"))
# 将response的 body 发送给浏览器
new_socket.send(html_content)
# 3.关闭套接字
new_socket.close()
def main():
"""用来完成整体的控制"""
# 1.创建套接字
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 2.绑定
tcp_server_socket.bind(("192.168.3.6", 7590))
# 3.变为监听套接字
tcp_server_socket.listen(128)
while True:
# 4.等待客户端的链接
new_socket, client_addr = tcp_server_socket.accept()
# 5.开辟一个进程为这个客户端服务
p = multiprocessing.Process(target=server_client,args=(new_socket,))
p.start()
new_socket.close()
# 6.关闭监听的套接字
tcp_server_socket.close()
if __name__ == '__main__':
main()
提示：上面代码在while True:里面有一个：new_socket.close(),因为进程是复制一份资源，进程里面有一个new_socket指向资源，主进程也有一份指向资源，等子进程new_socket调用close()的时候，资源不会被释放，所以在主进程先把指向子进程的资源释放掉
缺点：每一个子进程都要复制一份资源，如果很多很多客户端，那么服务器的内存就很快用完，服务器会承受不了，那么我们就需要用多线程了
4.3、多线程实现http服务器
把上面代码在while True:改为如下
import threading
while True:
# 4.等待客户端的链接
new_socket, client_addr = tcp_server_socket.accept()
# 5.开辟一个进程为这个t客户端服务
t = threading.Thread(target=server_client,args=(new_socket,))
t.start()
提示：上面代码在while True:里面没有一个：new_socket.close(),因为多线程没有复制一份资源，子线程 new_socket 调用close()的时候，资源被释放
缺点：每一个子线程都要开辟一条线程，如果很多很多客户端，那么服务器也会受不了的，并不是子线程越多越好
4.3、协程gevent实现http服务器
import gevent
from gevent import monkey
# 将程序中用到的耗时操作的代码，换为gevent中自己实现的模块
monkey.patch_all()
while True:
# 4.等待客户端的链接
new_socket, client_addr = tcp_server_socket.accept()
# 5.开辟一个协程为这个t客户端服务
gevent.spawn(server_client,new_socket)
4.4、单进程非堵塞 模型
from socket import *
import time
# 用来存储所有的新链接的socket
g_socket_list = list()
def main():
server_socket = socket(AF_INET, SOCK_STREAM)
server_socket.setsockopt(SOL_SOCKET, SO_REUSEADDR , 1)
server_socket.bind(('', 7890))
server_socket.listen(128)
# 将套接字设置为非堵塞
# 设置为非堵塞后，如果accept时，恰巧没有客户端connect，那么accept会
# 产生一个异常，所以需要try来进行处理
server_socket.setblocking(False)
while True:
# 用来测试
time.sleep(0.5)
try:
newClientInfo = server_socket.accept()
except Exception as result:
pass
else:
print("一个新的客户端到来:%s" % str(newClientInfo))
newClientInfo[0].setblocking(False) # 设置为非堵塞
g_socket_list.append(newClientInfo)
for client_socket, client_addr in g_socket_list:
try:
recvData = client_socket.recv(1024)
if recvData:
print('recv[%s]:%s' % (str(client_addr), recvData))
else:
print('[%s]客户端已经关闭' % str(client_addr))
client_socket.close()
g_socket_list.remove((client_socket,client_addr))
except Exception as result:
pass
print(g_socket_list) # for test
if __name__ == '__main__':
main()
4.5、epoll
IO 多路复用
就是我们说的select，poll，epoll，有些地方也称这种IO方式为event driven IO。
select/epoll的好处就在于单个process就可以同时处理多个网络连接的IO。
它的基本原理就是select，poll，epoll这个function会不断的轮询所负责的所有socket，当某个socket有数据到达了，就通知用户进程。
epoll 简单模型
import socket
import select
# 创建套接字
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 设置可以重复使用绑定的信息
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,1)
# 绑定本机信息
s.bind(("",7788))
# 变为被动
s.listen(128)
# 创建一个epoll对象
epoll = select.epoll()
# 测试，用来打印套接字对应的文件描述符
# print(s.fileno())
# print(select.EPOLLIN|select.EPOLLET)
# 注册事件到epoll中
# epoll.register(fd[, eventmask])
# 注意，如果fd已经注册过，则会发生异常
# 将创建的套接字添加到epoll的事件监听中
epoll.register(s.fileno(), select.EPOLLIN|select.EPOLLET)
connections = {}
addresses = {}
# 循环等待客户端的到来或者对方发送数据
while True:
# epoll 进行 fd 扫描的地方 -- 未指定超时时间则为阻塞等待
epoll_list = epoll.poll()
# 对事件进行判断
for fd, events in epoll_list:
# print fd
# print events
# 如果是socket创建的套接字被激活
if fd == s.fileno():
new_socket, new_addr = s.accept()
print('有新的客户端到来%s' % str(new_addr))
# 将 conn 和 addr 信息分别保存起来
connections[new_socket.fileno()] = new_socket
addresses[new_socket.fileno()] = new_addr
# 向 epoll 中注册 新socket 的 可读 事件
epoll.register(new_socket.fileno(), select.EPOLLIN|select.EPOLLET)
# 如果是客户端发送数据
elif events == select.EPOLLIN:
# 从激活 fd 上接收
recvData = connections[fd].recv(1024).decode("utf-8")
if recvData:
print('recv:%s' % recvData)
else:
# 从 epoll 中移除该 连接 fd
epoll.unregister(fd)
# server 侧主动关闭该 连接 fd
connections[fd].close()
print("%s---offline---" % str(addresses[fd]))
del connections[fd]
del addresses[fd]
说明
-EPOLLIN（可读）
-EPOLLOUT（可写）
-EPOLLET（ET模式）
epoll 对文件描述符的操作有两种模式：LT（level trigger）和ET（edge trigger）。LT模式是默认模式，LT模式与ET模式的区别如下：
LT模式：当epoll检测到描述符事件发生并将此事件通知应用程序，应用程序可以不立即处理该事件。下次调用epoll时，会再次响应应用程序并通知此事件。
ET模式：当epoll检测到描述符事件发生并将此事件通知应用程序，应用程序必须立即处理该事件。如果不处理，下次调用epoll时，不会再次响应应用程序并通知此事件。
web静态服务器-epool:以下代码，支持http的长连接，即使用了Content-Length(也就是返回内容的长度)
import socket
import time
import sys
import re
import select
class WSGIServer(object):
"""定义一个WSGI服务器的类"""
def __init__(self, port, documents_root):
# 1. 创建套接字
self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 2. 绑定本地信息
self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.server_socket.bind(("", port))
# 3. 变为监听套接字
self.server_socket.listen(128)
self.documents_root = documents_root
# 创建epoll对象
self.epoll = select.epoll()
# 将tcp服务器套接字加入到epoll中进行监听
self.epoll.register(self.server_socket.fileno(), select.EPOLLIN|select.EPOLLET)
# 创建添加的fd对应的套接字
self.fd_socket = dict()
def run_forever(self):
"""运行服务器"""
# 等待对方链接
while True:
# epoll 进行 fd 扫描的地方 -- 未指定超时时间则为阻塞等待
epoll_list = self.epoll.poll()
# 对事件进行判断
for fd, event in epoll_list:
# 如果是服务器套接字可以收数据，那么意味着可以进行accept
if fd == self.server_socket.fileno():
new_socket, new_addr = self.server_socket.accept()
# 向 epoll 中注册 连接 socket 的 可读 事件
self.epoll.register(new_socket.fileno(), select.EPOLLIN | select.EPOLLET)
# 记录这个信息
self.fd_socket[new_socket.fileno()] = new_socket
# 接收到数据
elif event == select.EPOLLIN:
request = self.fd_socket[fd].recv(1024).decode("utf-8")
if request:
self.deal_with_request(request, self.fd_socket[fd])
else:
# 在epoll中注销客户端的信息
self.epoll.unregister(fd)
# 关闭客户端的文件句柄
self.fd_socket[fd].close()
# 在字典中删除与已关闭客户端相关的信息
del self.fd_socket[fd]
def deal_with_request(self, request, client_socket):
"""为这个浏览器服务器"""
if not request:
return
request_lines = request.splitlines()
for i, line in enumerate(request_lines):
print(i, line)
# 提取请求的文件(index.html)
# GET /a/b/c/d/e/index.html HTTP/1.1
ret = re.match(r"([^/]*)([^ ]+)", request_lines[0])
if ret:
print("正则提取数据:", ret.group(1))
print("正则提取数据:", ret.group(2))
file_name = ret.group(2)
if file_name == "/":
file_name = "/index.html"
# 读取文件数据
try:
f = open(self.documents_root+file_name, "rb")
except:
response_body = "file not found, 请输入正确的url"
response_header = "HTTP/1.1 404 not found\r\n"
response_header += "Content-Type: text/html; charset=utf-8\r\n"
response_header += "Content-Length: %d\r\n" % len(response_body)
response_header += "\r\n"
# 将header返回给浏览器
client_socket.send(response_header.encode('utf-8'))
# 将body返回给浏览器
client_socket.send(response_body.encode("utf-8"))
else:
content = f.read()
f.close()
response_body = content
response_header = "HTTP/1.1 200 OK\r\n"
response_header += "Content-Length: %d\r\n" % len(response_body)
response_header += "\r\n"
# 将数据返回给浏览器
client_socket.send(response_header.encode("utf-8")+response_body)
# 设置服务器服务静态资源时的路径
DOCUMENTS_ROOT = "./html"
def main():
"""控制web服务器整体"""
# python3 xxxx.py 7890
if len(sys.argv) == 2:
port = sys.argv[1]
if port.isdigit():
port = int(port)
else:
print("运行方式如: python3 xxx.py 7890")
return
print("http服务器使用的port:%s" % port)
http_server = WSGIServer(port, DOCUMENTS_ROOT)
http_server.run_forever()
if __name__ == "__main__":
main()
总结：I/O 多路复用的特点：‘
通过一种机制使一个进程能同时等待多个文件描述符，而这些文件描述符（套接字描述符）其中的任意一个进入读就绪状态，epoll()函数就可以返回。 所以, IO多路复用，本质上不会有并发的功能，因为任何时候还是只有一个进程或线程进行工作，它之所以能提高效率是因为select\epoll 把进来的socket放到他们的 '监视' 列表里面，当任何socket有可读可写数据立马处理，那如果select\epoll 手里同时检测着很多socket， 一有动静马上返回给进程处理，总比一个一个socket过来,阻塞等待,处理高效率。
当然也可以多线程/多进程方式，一个连接过来开一个进程/线程处理，这样消耗的内存和进程切换页会耗掉更多的系统资源。 所以我们可以结合IO多路复用和多进程/多线程 来高性能并发，IO复用负责提高接受socket的通知效率，收到请求后，交给进程池/线程池来处理逻辑。
作者：IIronMan
链接：https://www.jianshu.com/p/75e64490dc5c
来源：
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。