http协议、web服务器、并发服务器（下）

Web静态服务器-5-非堵塞模式

单进程非堵塞模型

import socket
import time

def main():

	tcp_socket_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
	tcp_socket_server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
	tcp_socket_server.bind(("", 8090))

	tcp_socket_server.listen(128)
	# 设置为非阻塞
	tcp_socket_server.setblocking(False)	
	
	client_socket_list = list()
	
	while True:
		
		time.sleep(0.5)
		
		try:
			new_client, client_addr = tcp_socket_server.accept()	

		except:
			print("--没有新的客户端到来--")
		else:
			print("--新的客户端到了了--")
			new_client.setblocking(False) # 设置为非阻塞
			client_socket_list.append(new_client)

		for client_socket in client_socket_list:
			try:
				recv_data = client_socket.recv(1024)			

			except Exception as e:	
				print(e)
				print("没有新的数据到来")
			else:
				print("消灭或死亡")
				print(recv_data)
				if recv_data:
					print("客户端发送来了数据")
				else:
					client_socket.close()
					client_socket_list.remove(client_socket)
					print("关闭客户端")				


if __name__ == "__main__":
	main()

web静态服务器-单进程非堵塞

import socket
import re


def handle_client(new_client, recv_data):
	"""处理客户端请求"""

	# GET / HTTP/1.1
	request_header_lines = recv_data.splitlines()
	for line in request_header_lines:
		print(line)
	http_request_line = request_header_lines[0];
	get_file_name = re.match("[^/]+(/[^ ]*)", http_request_line).group(1)
	print("file name is -> " + get_file_name)	

	# print(recv_data)
	if get_file_name == "/":
		get_file_name = "/index.html"	

	root_path = "./html"
	get_file_name = root_path + get_file_name;
	try:
		f = open(get_file_name, "rb")
	except:
		response_body = b"page not found"
		response_headers = "HTTP/1.1 404 NOT FOUND\r\n"
		response_headers += "Content-Length: %d\r\n" % len(response_body)
		response_headers += "\r\n"
	else:	
	
		# 组装响应的内容
		response_body = f.read()
		response_headers = "HTTP/1.1 200 OK\r\n"
		response_headers += "Content-Length: %d\r\n" % len(response_body)
		response_headers += "\r\n"
		f.close()
	
	new_client.send(response_headers.encode("utf-8"))
	new_client.send(response_body)

	# new_client.close()


def main():
	
	# 创建套接字
	tcp_socket_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
	tcp_socket_server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)	
	
	# 绑定本地消息
	tcp_socket_server.bind(("", 8090))

	# 套接字由主动变被动
	tcp_socket_server.listen(128)

	# 设置为非堵塞
	tcp_socket_server.setblocking(False)
	
	client_socket_list = list()

	while True:
		
		try:
			# 接收新的请求
			new_client, client_addr = tcp_socket_server.accept()
		except Exception as ret:
			pass
		else:
			new_client.setblocking(False)
			client_socket_list.append(new_client)
		
		for client_socket in client_socket_list:
			try:
				recv_data = client_socket.recv(1024).decode("utf-8")
			except:
				pass
			else:
				if recv_data:
					handle_client(client_socket, recv_data)					
				else:
					client_socket.close()
					client_socket_list.remove(client_socket)
				

	# 关闭套接字
	tcp_socket_server.close()


if __name__ == "__main__":

	main()

Web静态服务器-6-epoll

IO 多路复用

就是我们说的select，poll，epoll，有些地方也称这种IO方式为event driven IO。

select/epoll的好处就在于单个process就可以同时处理多个网络连接的IO。

它的基本原理就是select，poll，epoll这个function会不断的轮询所负责的所有socket，当某个socket有数据到达了，就通知用户进程。

web静态服务器-epool

示例代码如下：

import socket
import re
import select


def handle_client(new_client, recv_data):
	"""处理客户端请求"""

	# GET / HTTP/1.1
	request_header_lines = recv_data.splitlines()
	for line in request_header_lines:
		print(line)
	http_request_line = request_header_lines[0];
	get_file_name = re.match("[^/]+(/[^ ]*)", http_request_line).group(1)
	print("file name is -> " + get_file_name)	

	# print(recv_data)
	if get_file_name == "/":
		get_file_name = "/index.html"	

	root_path = "./html"
	get_file_name = root_path + get_file_name;
	try:
		f = open(get_file_name, "rb")
	except:
		response_body = b"page not found"
		response_headers = "HTTP/1.1 404 NOT FOUND\r\n"
		response_headers += "Content-Length: %d\r\n" % len(response_body)
		response_headers += "\r\n"
	else:	
	
		# 组装响应的内容
		response_body = f.read()
		response_headers = "HTTP/1.1 200 OK\r\n"
		response_headers += "Content-Length: %d\r\n" % len(response_body)
		response_headers += "\r\n"
		f.close()
	
	new_client.send(response_headers.encode("utf-8"))
	new_client.send(response_body)

	# new_client.close()


def main():
	
	# 创建套接字
	tcp_socket_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
	tcp_socket_server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)	
	
	# 绑定本地消息
	tcp_socket_server.bind(("", 8090))

	# 套接字由主动变被动
	tcp_socket_server.listen(128)

	# 创建epoll对象
	epoll = select.epoll()

	epoll.register(tcp_socket_server.fileno(), select.EPOLLIN)	
	
	new_client_dict = dict()

	while True:
		
		epoll_list = epoll.poll()
		
		for fd, events in epoll_list:

			if fd == tcp_socket_server.fileno():
				new_client, client_addr = tcp_socket_server.accept()
				new_client_dict[new_client.fileno()] = new_client
				epoll.register(new_client.fileno(), select.EPOLLIN)
			elif events == select.EPOLLIN:
				
				recv_data = new_client_dict[fd].recv(1024).decode("utf-8")
		
				if recv_data:
					handle_client(new_client_dict[fd], recv_data)					
				else:
					epoll.unregister(new_client_dict[fd])
					new_client_dict[fd].close()
					del new_client_dict[fd]	

	# 关闭套接字
	tcp_socket_server.close()


if __name__ == "__main__":

	main()

说明：

• EPOLLIN （可读）
• EPOLLOUT （可写）
• EPOLLET （ET模式）

epoll对文件描述符的操作有两种模式：LT（level trigger）和ET（edge trigger）。LT模式是默认模式，LT模式与ET模式的区别如下：

LT模式：当epoll检测到描述符事件发生并将此事件通知应用程序，应用程序可以不立即处理该事件。下次调用epoll时，会再次响应应用程序并通知此事件。
ET模式：当epoll检测到描述符事件发生并将此事件通知应用程序，应用程序必须立即处理该事件。如果不处理，下次调用epoll时，不会再次响应应用程序并通知此事件。

I/O 多路复用的特点：

通过一种机制使一个进程能同时等待多个文件描述符，而这些文件描述符（套接字描述符）其中的任意一个进入读就绪状态，epoll()函数就可以返回。 所以, IO多路复用，本质上不会有并发的功能，因为任何时候还是只有一个进程或线程进行工作，它之所以能提高效率是因为select\epoll 把进来的socket放到他们的 '监视' 列表里面，当任何socket有可读可写数据立马处理，那如果select\epoll 手里同时检测着很多socket， 一有动静马上返回给进程处理，总比一个一个socket过来,阻塞等待,处理高效率。

当然也可以多线程/多进程方式，一个连接过来开一个进程/线程处理，这样消耗的内存和进程切换页会耗掉更多的系统资源。 所以我们可以结合IO多路复用和多进程/多线程 来高性能并发，IO复用负责提高接受socket的通知效率，收到请求后，交给进程池/线程池来处理逻辑。