本章内容:
- Socket
- IO多路复用(select)
- SocketServer 模块(ThreadingTCPServer源码剖析)
- 事件驱动
一、socket
socket通常也称作"套接字",用于描述IP地址和端口,是一个通信链的句柄,应用程序通常通过"套接字"向网络发出请求或者应答网络请求。
socket起源于Unix,而Unix/Linux基本哲学之一就是“一切皆文件”,对于文件用【打开】【读写】【关闭】模式来操作。socket就是该模式的一个实现,socket即是一种特殊的文件,一些socket函数就是对其进行的操作(读/写IO、打开、关闭)
socket和file的区别:
- file模块是针对某个指定文件进行【打开】【读写】【关闭】
- socket模块是针对 服务器端 和 客户端Socket 进行【打开】【读写】【关闭】
tcp_socket_server:
# -*- coding: utf-8 -*-
import socket
ip_port = ('127.0.0.1', 9999)
sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM,0)
sk.bind(ip_port)
sk.listen(5) #也叫半链接池的最大数
while True:
print('server waiting...')
conn, addr = sk.accept()
client_data = conn.recv(1024)
print(client_data.decode('utf-8'))
conn.sendall('不要回答,不要回答,不要回答'.encode('utf-8'))
conn.close()
tcp_socket_client:
# -*- coding: utf-8 -*-
import socket
ip_port = ('127.0.0.1', 9999)
sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM,0)
sk.connect(ip_port)
sk.sendall('请求占领地球'.encode('utf-8'))
server_reply = sk.recv(1024)
print(server_reply.decode('utf-8'))
sk.close()
更多功能
sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM,0)
参数一:地址簇
socket.AF_INET IPv4(默认)
socket.AF_INET6 IPv6socket.AF_UNIX 只能够用于单一的Unix系统进程间通信
参数二:类型
socket.SOCK_STREAM 流式socket , for TCP (默认)
socket.SOCK_DGRAM 数据报式socket , for UDPsocket.SOCK_RAW 原始套接字,普通的套接字无法处理ICMP、IGMP等网络报文,而SOCK_RAW可以;其次,SOCK_RAW也可以处理特殊的IPv4报文;此外,利用原始套接字,可以通过IP_HDRINCL套接字选项由用户构造IP头。
socket.SOCK_RDM 是一种可靠的UDP形式,即保证交付数据报但不保证顺序。SOCK_RAM用来提供对原始协议的低级访问,在需要执行某些特殊操作时使用,如发送ICMP报文。SOCK_RAM通常仅限于高级用户或管理员运行的程序使用。
socket.SOCK_SEQPACKET 可靠的连续数据包服务参数三:协议
0 (默认)与特定的地址家族相关的协议,如果是 0 ,则系统就会根据地址格式和套接类别,自动选择一个合适的协议
UDP Demo:
import socket
ip_port = ('127.0.0.1',9999)
sk = socket.socket(socket.AF_INET,socket.SOCK_DGRAM,0)
sk.bind(ip_port)
while True:
data = sk.recv(1024)
print (data)
import socket
ip_port = ('127.0.0.1',9999)
sk = socket.socket(socket.AF_INET,socket.SOCK_DGRAM,0)
while True:
inp = raw_input('数据:').strip()
if inp == 'exit':
break
sk.sendto(inp,ip_port)
sk.close()
sk.bind(address)
s.bind(address) 将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下,以元组(host,port)的形式表示地址。
sk.listen(backlog)
开始监听传入连接。backlog指定在拒绝连接之前,可以挂起的最大连接数量。
backlog等于5,表示内核已经接到了连接请求,但服务器还没有调用accept进行处理的连接个数最大为5
这个值不能无限大,因为要在内核中维护连接队列
sk.setblocking(bool)
是否阻塞(默认True),如果设置False,那么accept和recv时一旦无数据,则报错。
sk.accept()
接受连接并返回(conn,address),其中conn是新的套接字对象,可以用来接收和发送数据。address是连接客户端的地址。
接收TCP 客户的连接(阻塞式)等待连接的到来
sk.connect(address)
连接到address处的套接字。一般,address的格式为元组(hostname,port),如果连接出错,返回socket.error错误。
sk.connect_ex(address)
同上,只不过会有返回值,连接成功时返回 0 ,连接失败时候返回编码,例如:10061
sk.close()
关闭套接字
sk.recv(bufsize[,flag])
接受套接字的数据。数据以字符串形式返回,bufsize指定最多可以接收的数量。flag提供有关消息的其他信息,通常可以忽略。
sk.recvfrom(bufsize[.flag])
与recv()类似,但返回值是(data,address)。其中data是包含接收数据的字符串,address是发送数据的套接字地址。
sk.send(string[,flag])
将string中的数据发送到连接的套接字。返回值是要发送的字节数量,该数量可能小于string的字节大小。即:可能未将指定内容全部发送。
sk.sendall(string[,flag])
将string中的数据发送到连接的套接字,但在返回之前会尝试发送所有数据。成功返回None,失败则抛出异常。
内部通过递归调用send,将所有内容发送出去。
sk.sendto(string[,flag],address)
将数据发送到套接字,address是形式为(ipaddr,port)的元组,指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议。
sk.settimeout(timeout)
设置套接字操作的超时期,timeout是一个浮点数,单位是秒。值为None表示没有超时期。一般,超时期应该在刚创建套接字时设置,因为它们可能用于连接的操作(如 client 连接最多等待5s )
sk.getpeername()
返回连接套接字的远程地址。返回值通常是元组(ipaddr,port)。
sk.getsockname()
返回套接字自己的地址。通常是一个元组(ipaddr,port)
sk.fileno()
套接字的文件描述符
# 服务端
# -*- coding: utf-8 -*-
import socket
ip_port = ('127.0.0.1',9998)
sk = socket.socket(socket.AF_INET, socket.SOCK_DGRAM,0)
sk.bind(ip_port)
while True:
data, (host, port) = sk.recvfrom(1024)
if data.split()[0].decode('utf-8') == 'exit':
break
print(data.decode('utf-8'), host, port)
sk.sendto(bytes('你好',encoding='utf-8'),(host,port))
#客户端
# -*- coding: utf-8 -*-
import socket
ip_port = ('127.0.0.1',9998)
sk = socket.socket(socket.AF_INET, socket.SOCK_DGRAM,0)
while True:
inp = input('数据: ').strip()
if inp == 'exit':
break
sk.sendto(bytes(inp,encoding='utf-8'),ip_port)
data = sk.recvfrom(1024)
print(data)
sk.close()
设置socket
setsockopt()和getsockopt(),一个是设置选项,一个是得到设置。这里主要使用setsockopt(),setsockopt(level,optname,value),level定义了哪个选项将被使用。通常情况下是SOL_SOCKET,意思是正在使用的socket选项。
optname参数提供使用的特殊选项。关于可用选项的设置,会因为操作系统的不同而有少许不同。如果level选定了SOL_SOCKET,那么一些常用的选项见下表:
选项 | 意义 | 期望值 |
SO_BINDTODEVICE | 可以使socket只在某个特殊的网络接口(网卡)有效。也许不能是移动便携设备 | 一个字符串给出设备的名称或者一个空字符串返回默认值 |
SO_BROADCAST | 允许广播地址发送和接收信息包。只对UDP有效。如何发送和接收广播信息包 | 布尔型整数 |
SO_DONTROUTE | 禁止通过路由器和网关往外发送信息包。这主要是为了安全而用在以太网上UDP通信的一种方法。不管目的地址使用什么IP地址,都可以防止数据离开本地网络 | 布尔型整数 |
SO_KEEPALIVE | 可以使TCP通信的信息包保持连续性。这些信息包可以在没有信息传输的时候,使通信的双方确定连接是保持的 | 布尔型整数 |
SO_OOBINLINE | 可以把收到的不正常数据看成是正常的数据,也就是说会通过一个标准的对recv()的调用来接收这些数据 | 布尔型整数 |
SO_REUSEADDR | 当socket关闭后,本地端用于该socket的端口号立刻就可以被重用。通常来说,只有经过系统定义一段时间后,才能被重用。 | 布尔型整数 |
比较常用的用法是,setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) 这里value设置为1,表示将SO_REUSEADDR标记为TRUE,操作系统会在服务器socket被关闭或服务器进程终止后马上释放该服务器的端口,否则操作系统会保留几分钟该端口(一定要放在bind()之前)。
# -*- coding: utf-8 -*-
import socket
ip_port = ('127.0.0.1', 9999)
sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM,0)
setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
sk.bind(ip_port)
解决粘包的问题:
socket_server_tcp:主要命令使用了(subprocess、struct.pack)
from socket import *
import subprocess
import struct
ip_port=('127.0.0.1',8080)
back_log=5
buffer_size=1024
tcp_server=socket(AF_INET,SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)
while True:
conn,addr=tcp_server.accept()
print('新的客户端链接',addr)
while True:
#收
try:
cmd=conn.recv(buffer_size)
if not cmd:break
print('收到客户端的命令',cmd)
#执行命令,得到命令的运行结果cmd_res,通过管道把命令执行的结果重定向到三个标准里面而不是屏幕输出来
res=subprocess.Popen(cmd.decode('utf-8'),shell=True,
stderr=subprocess.PIPE,
stdout=subprocess.PIPE,
stdin=subprocess.PIPE)
err=res.stderr.read() #命令执行错误
if err:
cmd_res=err
else:
cmd_res=res.stdout.read()#命令执行成功
#发
if not cmd_res: #防止当执行../时没有返回值时会卡住
cmd_res='执行成功'.encode('gbk')
length=len(cmd_res)
data_length=struct.pack('i',length)#i代表整形,4外字节长度,直接生成字节类型的值
conn.send(data_length)
conn.send(cmd_res)
except Exception as e:
print(e)
break
socket_client_tcp:
from socket import *
import struct
from functools import partial
ip_port=('127.0.0.1',8080)
back_log=5
buffer_size=1024
tcp_client=socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)
while True:
cmd=input('>>: ').strip()
if not cmd:continue
if cmd == 'quit':break
tcp_client.send(cmd.encode('utf-8'))
#解决粘包
length_data=tcp_client.recv(4)
length=struct.unpack('i',length_data)[0]
recv_size=0
recv_msg=b''
while recv_size < length:
recv_msg += tcp_client.recv(buffer_size)
recv_size=len(recv_msg) #1024
print('命令的执行结果是 ',recv_msg.decode('gbk'))
tcp_client.close()
二、IO多路复用
I/O多路复用指:通过一种机制,可以监视多个描述符,一旦某个描述符就绪(一般是读就绪或者写就绪),能够通知程序进行相应的读写操作。
Linux
Linux中的 select,poll,epoll 都是IO多路复用的机制。
|
Python
Python中有一个select模块,其中提供了:select、poll、epoll三个方法,分别调用系统的 select,poll,epoll 从而实现IO多路复用。
|
注意:网络操作、文件操作、终端操作等均属于IO操作,对于windows只支持Socket操作,其他系统支持其他IO操作,但是无法检测 普通文件操作 自动上次读取是否已经变化。
对于select方法:
|
利用select监听终端操作实例
# serve.py
# 用select 实现监听多个端口,并实现读写分离
import select
import socket
sk = socket.socket()
sk.bind(('127.0.0.1', 8000,))
sk.listen(5)
inputs = [sk]
outputs = []
message_dict = {} # 存储每个客户端接受到的信息
while True:
r_list, w_list, e_list = select.select(inputs, outputs, [], 1)
print(len(inputs))
for sk_or_conn in r_list:
if sk_or_conn == sk: # 一旦有客户端连接,sk发生变化
conn, addr = sk.accept()
inputs.append(conn) # 将客户端的conn添加到监听列表
message_dict[conn] = [] # 以客户端的conn为key,生成一个新列表来存储接受到的信息
# conn.sendall(bytes('hello', encoding='utf-8'))
else:
try:
ret = sk_or_conn.recv(1024) # 监听的列表里面如果有客户端发送信息,
except Exception as ex:
inputs.remove(sk_or_conn) # 如果客户端断开的话,从监听的列表里面移除
else:
data = str(ret, encoding='utf-8')
message_dict[sk_or_conn].append(data) # 将监听的信息放到字典里
outputs.append(sk_or_conn) # 放到outputs里面
# sk_or_conn.sendall(bytes(data+'hello', encoding='utf-8'))
for conn in w_list: # 单独实现写的操作
message = message_dict[conn][0]
conn.sendall(bytes(message+'hello', encoding='utf-8'))
del message_dict[conn][0]
outputs.remove(conn)
#client1.py
import socket
client_socket = socket.socket()
client_socket.connect(('127.0.0.1', 8000,))
while True:
inp = input('>>>')
client_socket.sendall(bytes(inp, encoding='utf-8'))
data = str(client_socket.recv(1024), encoding='utf-8')
print(data)
client_socket.close()
#client.py2
import socket
client_socket = socket.socket()
client_socket.connect(('127.0.0.1', 8000,))
while True:
inp = input('>>>')
client_socket.sendall(bytes(inp, encoding='utf-8'))
data = str(client_socket.recv(1024), encoding='utf-8')
print(data)
client_socket.close()
事件机制的select调用:
服务器端:
class TCPServer:
def __init__(self, server, server_address, inputs, outputs, message_queues):
# Create a TCP/IP
self.server = server
self.server.setblocking(False)
# Bind the socket to the port
self.server_address = server_address
print('starting up on %s port %s' % self.server_address)
self.server.bind(self.server_address)
# Listen for incoming connections
self.server.listen(5)
# Sockets from which we expect to read
self.inputs = inputs
# Sockets to which we expect to write
# 处理要发送的消息
self.outputs = outputs
# Outgoing message queues (socket: Queue)
self.message_queues = message_queues
def handler_recever(self, readable):
# Handle inputs
# 循环判断是否有客户端连接进来, 当有客户端连接进来时select 将触发
for s in readable:
# 判断当前触发的是不是服务端对象, 当触发的对象是服务端对象时,说明有新客户端连接进来了
# 表示有新用户来连接
if s is self.server:
# A "readable" socket is ready to accept a connection
connection, client_address = s.accept()
self.client_address = client_address
print('connection from', client_address)
# this is connection not server
connection.setblocking(0)
# 将客户端对象也加入到监听的列表中, 当客户端发送消息时 select 将触发
self.inputs.append(connection)
# Give the connection a queue for data we want to send
# 为连接的客户端单独创建一个消息队列,用来保存客户端发送的消息
self.message_queues[connection] = queue.Queue()
else:
# 有老用户发消息, 处理接受
# 由于客户端连接进来时服务端接收客户端连接请求,将客户端加入到了监听列表中(input_list), 客户端发送消息将触发
# 所以判断是否是客户端对象触发
data = s.recv(1024)
# 客户端未断开
if data != b'':
# A readable client socket has data
# 可读的客户机套接字具有数据
print('received "%s" from %s' % (data, s.getpeername()))
# 将收到的消息放入到相对应的socket客户端的消息队列中
self.message_queues[s].put(data)
# Add output channel for response
# 将需要进行回复操作socket放到output 列表中, 让select监听
if s not in self.outputs:
self.outputs.append(s)
else:
# 客户端断开了连接, 将客户端的监听从input列表中移除
# Interpret empty result as closed connection
print('closing ', s.getpeername()) # 获取客户端的socket信息
# 停止监听连接上的输入
# Stop listening for input on the connection
if s in self.outputs:
self.outputs.remove(s)
self.inputs.remove(s)
s.close()
# Remove message queue
# 移除对应socket客户端对象的消息队列
del self.message_queues[s]
return "got it"
def handler_send(self, writable):
# Handle outputs
# 如果现在没有客户端请求, 也没有客户端发送消息时, 开始对发送消息列表进行处理, 是否需要发送消息
# 存储哪个客户端发送过消息
for s in writable:
try:
# 如果消息队列中有消息,从消息队列中获取要发送的消息
message_queue = self.message_queues.get(s)
send_data = ''
if message_queue is not None:
send_data = message_queue.get_nowait()
except queue.Empty:
# 客户端连接断开了
self.outputs.remove(s)
else:
# print "sending %s to %s " % (send_data, s.getpeername)
# print "send something"
if message_queue is not None:
s.send(send_data)
else:
print("client has closed")
# del message_queues[s]
# writable.remove(s)
# print "Client %s disconnected" % (client_address)
return "got it"
def handler_exception(self, exceptional):
# # Handle "exceptional conditions"
# 处理异常的情况
for s in exceptional:
print('exception condition on', s.getpeername())
# Stop listening for input on the connection
self.inputs.remove(s)
if s in self.outputs:
self.outputs.remove(s)
s.close()
# Remove message queue
del self.message_queues[s]
return "got it"
def event_loop(tcpserver, inputs, outputs):
while inputs:
# Wait for at least one of the sockets to be ready for processing 等待至少一个套接字准备好进行处理
print('waiting for the next event')
# 开始select 监听, 对input_list 中的服务器端server 进行监听
# 当socket调用send, recv等函数时, 就会再次调用此函数, 这时返回的第二个参数就会有值
readable, writable, exceptional = select.select(inputs, outputs, inputs)
readable, writable, exceptional = select.select(inputs, outputs, inputs)
if readable is not None:
tcp_recever = tcpserver.handler_recever(readable)
if tcp_recever == 'got it':
print("server have received")
if writable is not None:
tcp_send = tcpserver.handler_send(writable)
if tcp_send == 'got it':
print("server have send")
if exceptional is not None:
tcp_exception = tcpserver.handler_exception(exceptional)
if tcp_exception == 'got it':
print("server have exception")
sleep(0.8)
if __name__ == '__main__':
server_address = ('localhost', 8090)
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
inputs = [server]
outputs = []
message_queues = {}
tcpserver = TCPServer(server, server_address, inputs, outputs, message_queues)
# 开启事件循环
event_loop(tcpserver, inputs, outputs)
客户端:
import socket
messages = ['This is the message ', 'It will be sent ', 'in parts ', ]
server_address = ('localhost', 8090)
# Create aTCP/IP socket
socks = [socket.socket(socket.AF_INET, socket.SOCK_STREAM), socket.socket(socket.AF_INET, socket.SOCK_STREAM), ]
# Connect thesocket to the port where the server is listening
print('connecting to %s port %s' % server_address)
# 连接到服务器
for s in socks:
s.connect(server_address)
for index, message in enumerate(messages):
# Send messages on both sockets
for s in socks:
print('%s: sending "%s"' % (s.getsockname(), message + str(index)))
send_data = message + str(index)
s.sendall(bytes(send_data, encoding='utf-8'))
# Read responses on both sockets
for s in socks:
data = s.recv(1024)
print('%s: received "%s"' % (s.getsockname(), data))
if data != "":
print('closingsocket', s.getsockname())
s.close()
三、SocketServer模块
SocketServer内部使用 IO多路复用 以及 “多线程” 和 “多进程” ,从而实现并发处理多个客户端请求的Socket服务端。即:每个客户端请求连接到服务器时,Socket服务端都会在服务器是创建一个“线程”或者“进程” 专门负责处理当前客户端的所有请求。
继承关系(全都要通过实例化s,也就是继承的顺序开始查找对应的方法):
ThreadingTCPServer
ThreadingTCPServer实现的Soket服务器内部会为每个client创建一个 “线程”,该线程用来和客户端进行交互。
1、ThreadingTCPServer基础
使用ThreadingTCPServer:
- 创建一个继承自 SocketServer.BaseRequestHandler 的类
- 类中必须定义一个名称为 handle 的方法
- 启动ThreadingTCPServer
服务端socketserver:
import socketserver
'''
def __init__(self, request, client_address, server):
self.request = request
self.client_address = client_address
self.server = server
self.setup()
try:
self.handle()
finally:
self.finish()
'''
class MyServer(socketserver.BaseRequestHandler):
def handle(self): #最后一步看基类的init方法,里面调用handle
print('conn is: ',self.request) #conn
print('addr is: ',self.client_address) #addr
while True:
try:
#收消息
data=self.request.recv(1024)
if not data:break
print('收到客户端的消息是',data,self.client_address)
#发消息
self.request.sendall(data.upper())
except Exception as e:
print(e)
break
if __name__ == '__main__':
s=socketserver.ThreadingTCPServer(('127.0.0.1',8080),MyServer) #多线程
# s=socketserver.ForkingTCPServer(('127.0.0.1',8080),MyServer) #多进程
# self.server_address = server_address
# self.RequestHandlerClass = RequestHandlerClass
print(s.server_address)
print(s.RequestHandlerClass)
print(MyServer)
print(s.socket)
print(s.server_address)
s.serve_forever() #主要看这个self._handle_request_noblock(),然后根据继承关系找
客户端socketclient版(可以创建多个客户端来连接):
from socket import *
ip_port=('127.0.0.1',8080)
back_log=5
buffer_size=1024
tcp_client=socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)
while True:
msg=input('>>: ').strip()
if not msg:continue
if msg == 'quit':break
tcp_client.send(msg.encode('utf-8'))
data=tcp_client.recv(buffer_size)
print('收到服务端发来的消息:',data.decode('utf-8'))
tcp_client.close()
实例:
服务器端:
# -*- coding: utf-8 -*-
import socketserver
class MyServer(socketserver.BaseRequestHandler):
def handle(self):
print(self.request,self.client_address,self.server)
conn = self.request
conn.sendall('欢迎致电 10086,请输入1xxx,0转人工服务.'.encode('utf-8'))
Flag = True
while Flag:
data = conn.recv(1024).decode('utf-8')
if data == 'exit':
Flag = False
elif data == '0':
conn.sendall('通过可能会被录音.balabala一大推'.encode('utf-8'))
else:
conn.sendall('请重新输入.'.encode('utf-8'))
if __name__ == '__main__':
server = socketserver.ThreadingTCPServer(('127.0.0.1',8009),MyServer)
server.serve_forever()
客户端:
# -*- coding: utf-8 -*-
import socket
ip_port = ('127.0.0.1',8009)
sk = socket.socket()
sk.connect(ip_port)
sk.settimeout(5)
while True:
data = sk.recv(1024)
print ('receive:',data.decode('utf-8'))
inp = input('please input:')
sk.sendall(inp.encode('utf-8'))
if inp == 'exit':
break
sk.close()
SocketServer的ThreadingTCPServer之所以可以同时处理请求得益于 select 和 Threading 两个东西,其实本质上就是在服务器端为每一个客户端创建一个线程,当前线程用来处理对应客户端的请求,所以,可以支持同时n个客户端链接(长连接)。
ForkingTCPServer
ForkingTCPServer和ThreadingTCPServer的使用和执行流程基本一致,只不过在内部分别为请求者建立 “线程” 和 “进程”。
基本使用:
服务器端:
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import SocketServer
class MyServer(SocketServer.BaseRequestHandler):
def handle(self):
# print self.request,self.client_address,self.server
conn = self.request
conn.sendall('欢迎致电 10086,请输入1xxx,0转人工服务.')
Flag = True
while Flag:
data = conn.recv(1024)
if data == 'exit':
Flag = False
elif data == '0':
conn.sendall('通过可能会被录音.balabala一大推')
else:
conn.sendall('请重新输入.')
if __name__ == '__main__':
server = SocketServer.ForkingTCPServer(('127.0.0.1',8009),MyServer)
server.serve_forever()
客户端:
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import socket
ip_port = ('127.0.0.1',8009)
sk = socket.socket()
sk.connect(ip_port)
sk.settimeout(5)
while True:
data = sk.recv(1024)
print 'receive:',data
inp = raw_input('please input:')
sk.sendall(inp)
if inp == 'exit':
break
sk.close()
以上ForkingTCPServer只是将 ThreadingTCPServer 实例中的代码:
erver = SocketServer.ThreadingTCPServer(('127.0.0.1',8009),MyRequestHandler)
变更为:
server = SocketServer.ForkingTCPServer(('127.0.0.1',8009),MyRequestHandler)
SocketServer的ThreadingTCPServer之所以可以同时处理请求得益于 select 和 os.fork 两个东西,其实本质上就是在服务器端为每一个客户端创建一个进程,当前新创建的进程用来处理对应客户端的请求,所以,可以支持同时n个客户端链接(长连接)。
源码剖析参考 ThreadingTCPServer
四、事件驱动
简而言之,事件驱动分为二个部分:第一,注册事件;第二,触发事件。
自定义事件驱动框架,命名为:“弑君者”:
事件驱动框架:
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# event_drive.py
event_list = []
def run():
for event in event_list:
obj = event()
obj.execute()
class BaseHandler(object):
"""
用户必须继承该类,从而规范所有类的方法(类似于接口的功能)
"""
def execute(self):
raise Exception('you must overwrite execute')
程序员使用“弑君者框架”:
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from source import event_drive
class MyHandler(event_drive.BaseHandler):
def execute(self):
print 'event-drive execute MyHandler'
event_drive.event_list.append(MyHandler)
event_drive.run()
如上述代码,事件驱动只不过是框架规定了执行顺序,程序员在使用框架时,可以向原执行顺序中注册“事件”,从而在框架执行时可以出发已注册的“事件”。
基于事件驱动Socket
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from twisted.internet import protocol
from twisted.internet import reactor
class Echo(protocol.Protocol):
def dataReceived(self, data):
self.transport.write(data)
def main():
factory = protocol.ServerFactory()
factory.protocol = Echo
reactor.listenTCP(8000,factory)
reactor.run()
if __name__ == '__main__':
main()
程序执行流程:
- 运行服务端程序
- 创建Protocol的派生类Echo
- 创建ServerFactory对象,并将Echo类封装到其protocol字段中
- 执行reactor的 listenTCP 方法,内部使用 tcp.Port 创建socket server对象,并将该对象添加到了 reactor的set类型的字段 _read 中
- 执行reactor的 run 方法,内部执行 while 循环,并通过 select 来监视 _read 中文件描述符是否有变化,循环中...
- 客户端请求到达
- 执行reactor的 _doReadOrWrite 方法,其内部通过反射调用 tcp.Port 类的 doRead 方法,内部 accept 客户端连接并创建Server对象实例(用于封装客户端socket信息)和 创建 Echo 对象实例(用于处理请求) ,然后调用 Echo 对象实例的 makeConnection 方法,创建连接。
- 执行 tcp.Server 类的 doRead 方法,读取数据,
- 执行 tcp.Server 类的 _dataReceived 方法,如果读取数据内容为空(关闭链接),否则,出发 Echo 的 dataReceived 方法
- 执行 Echo 的 dataReceived 方法
从源码可以看出,上述实例本质上使用了事件驱动的方法 和 IO多路复用的机制来进行Socket的处理。
异步IO操作:
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from twisted.internet import reactor, protocol
from twisted.web.client import getPage
from twisted.internet import reactor
import time
class Echo(protocol.Protocol):
def dataReceived(self, data):
deferred1 = getPage('')
deferred1.addCallback(self.printContents)
deferred2 = getPage('http://baidu.com')
deferred2.addCallback(self.printContents)
for i in range(2):
time.sleep(1)
print 'execute ',i
def execute(self,data):
self.transport.write(data)
def printContents(self,content):
print len(content),content[0:100],time.time()
def main():
factory = protocol.ServerFactory()
factory.protocol = Echo
reactor.listenTCP(8000,factory)
reactor.run()
if __name__ == '__main__':
main()