ThreadingMixIn和ForkingMixIn类

异步混合&＃xff1a;

为了建立异步处理机制&＃xff0c;需要使用ThreadingMixIn和ForkingMixIn类。

以下是一个使用ThreadingMixIn类的示例:

import socket
import threading
import socketserverclass ThreadedTCPRequestHandler(socketserver.BaseRequestHandler):
def handle(self):
data &＃61; str(self.request.recv(1024), &＃39;ascii&＃39;)cur_thread &＃61; threading.current_thread()response &＃61; bytes("{}: {}".format(cur_thread.name, data), &＃39;ascii&＃39;)self.request.sendall(response)class ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
passdef client(ip, port, message):sock &＃61; socket.socket(socket.AF_INET, socket.SOCK_STREAM)sock.connect((ip, port))try:sock.sendall(bytes(message, &＃39;ascii&＃39;))response &＃61; str(sock.recv(1024), &＃39;ascii&＃39;)print("Received: {}".format(response))finally:sock.close()if __name__ &＃61;&＃61; "__main__":# Port 0 means to select an arbitrary unused portHOST, PORT &＃61; "localhost", 0server &＃61; ThreadedTCPServer((HOST, PORT), ThreadedTCPRequestHandler)
ip, port &＃61; server.server_address
# Start a thread with the server -- that thread will then start one# more thread for each requestserver_thread &＃61; threading.Thread(target&＃61;server.serve_forever)# Exit the server thread when the main thread terminatesserver_thread.daemon &＃61; Trueserver_thread.start()
print("Server loop running in thread:", server_thread.name)client(ip, port, "Hello World 1")client(ip, port, "Hello World 2")client(ip, port, "Hello World 3")
server.shutdown()

结果应该类似这样&＃xff1a;

Server loop running in thread: Thread-1
Received: Thread-2: Hello World 1
Received: Thread-3: Hello World 2
Received: Thread-4: Hello World 3

SocketServer是标准库中一个很具有代表性的库。它基于socket提供一套快速建立socket服务器的框架&＃xff0c;并可以通过Mix-in的技巧让单线程服务器进化为多线程或多进程服务器。Socketserver.py里面的类很多&＃xff0c;下面一个一个介绍并介绍它们之间关系。

BaseServer、TCPServer、UDPServer&＃xff0c;前者是后两者的父类。在父类中实现了TCP与UDP服务器可以共用的方法&＃xff0c;并留下了需要在子类中实现的抽象类。因此在实际工作中&＃xff0c;我们一般不应该继承BaseServer类&＃xff0c;除非你是为了自己去实现或重载某些方法。另外&＃xff0c;还有UnixStreamServer和UnixDatagramServer分别继承自TCPserver和UDPServer。这两个带Unix字样的类是用来构建*nix下本地socket的服务器&＃xff08;本地socket访问速度更快&＃xff0c;但只能用在本机的进程间通信&＃xff09;

接下来是ForkingMixIn和ThreadingMixIn两个混合类&＃xff0c;它们都提供Server类中process_request方法的新实现&＃xff0c;前者在处理每次用户连接的时候都会开启新的进程&＃xff0c;而后者会开启新的线程。想要让Server类实现并发处理&＃xff0c;只用利用多重继承即可。或者直接使用已经混合好的

class ForkingUDPServer(ForkingMixIn, UDPServer): pass

class ForkingTCPServer(ForkingMixIn, TCPServer): pass

class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass

class ThreadingTCPServer(ThreadingMixIn, TCPServer): pass

最后没有介绍的是BaseRequestHandler、StreamRequestHandler、DatagramRequestHandler&＃xff0c;同Server一样&＃xff0c;前者是后两者的父类用来提供公用的方法

通常在使用SocketServer的时候我们只用自己实例化一个合适的Server类&＃xff0c;并在实例化时传递其监听的IP、端口&＃xff0c;以及之前继承自某个RequestHandler的类&＃xff08;需要自行实现hanle方法&＃xff0c;作为server的请求处理器&＃xff09;

这里需要特别注意的&＃xff1a;

1.IP和端口是作为一个元组传递的而不是两个单独的参数。

2.每个客户连接都会在hanle方法运行完之后被关闭&＃xff0c;你如果不想关闭就需要重写Server中的def shutdown_request(self, request)方法

1.前言&＃xff1a;

       虽说用Python编写简单的网络程序很方便&＃xff0c;但复杂一点的网络程序还是用现成的框架比较好。这样就可以专心事务逻辑&＃xff0c;而不是套接字的各种细节。SocketServer模块简化了编写网络服务程序的任务。同时SocketServer模块也是Python标准库中很多服务器框架的基础。

2.网络服务类&＃xff1a;

SocketServer提供了4个基本的服务类&＃xff1a;

TCPServer针对TCP套接字流

UDPServer针对UDP数据报套接字

UnixStreamServer和UnixDatagramServer针对UNIX域套接字&＃xff0c;不常用。

它们的继承关系如下&＃xff1a;

&＃43;------------&＃43;
| BaseServer |
&＃43;------------&＃43;|v
&＃43;-----------&＃43; &＃43;------------------&＃43;
| TCPServer |------->| UnixStreamServer |
&＃43;-----------&＃43; &＃43;------------------&＃43;|v
&＃43;-----------&＃43; &＃43;--------------------&＃43;
| UDPServer |------->| UnixDatagramServer |
&＃43;-----------&＃43; &＃43;--------------------&＃43;

2.1异步处理&＃xff1a;

       这个四个服务类都是同步处理请求的。一个请求没处理完不能处理下一个请求。要想支持异步模型&＃xff0c;可以利用多继承让server类继承ForkingMixIn 或 ThreadingMixIn mix-in classes。

       ForkingMixIn利用多进程&＃xff08;分叉&＃xff09;实现异步。

       ThreadingMixIn利用多线程实现异步。

3.请求处理类&＃xff1a;

        要实现一项服务&＃xff0c;还必须派生一个handler class请求处理类&＃xff0c;并重写父类的handle()方法。handle方法就是用来专门是处理请求的。该模块是通过服务类和请求处理类组合来处理请求的。

        SocketServer模块提供的请求处理类有BaseRequestHandler&＃xff0c;以及它的派生类StreamRequestHandler和DatagramRequestHandler。从名字看出可以一个处理流式套接字&＃xff0c;一个处理数据报套接字。

4.总结用SocketServer创建一个服务的步骤&＃xff1a;

1.创建一个request handler class&＃xff08;请求处理类&＃xff09;&＃xff0c;继承自BaseRequestHandler class并重写它的handle()方法&＃xff0c;该方法将处理到的请求。
2.实例化一个server class对象&＃xff0c;并将服务的地址和之前创建的request handler class传递给它。
3.调用server class对象的handle_request() 或 serve_forever()方法来开始处理请求。

一个基于SocketServer的服务器示例&＃xff1a;

from SocketServer import TCPServer,StreamRequestHandler
#定义请求处理类
class Handler(StreamRequestHandler):def handle(self):addr &＃61; self.request.getpeername()print &＃39;Got connection from &＃39;,addrself.wfile.write(&＃39;Thank you for connecting&＃39;)server &＃61; TCPServer((&＃39;&＃39;,1234), handler) #实例化服务类对象server.server_forever() #开启服务


5.实现异步&＃xff0c;支持多连接

        前面介绍服务类时提到过&＃xff0c;四个基本的服务类默认是同步模型的。要想支持异步可以利用多继承从ForkingMixIn 或ThreadingMixInmix-in classes和一个基本的服务类继承来定义一个支持异步的服务类。比如&＃xff1a;

class Server(ThreadingMixIn, TCPServer): pass

         ForkingMixIn 要考虑进程间的通信。ThreadingMixIn要考虑线程访问同一变量时的同步和互斥。

 一个使用了多线程处理的服务器示例&＃xff1a;

from SocketServer import TCPServer, ThreadingMixIn, StreamRequestHandler#定义支持多线程的服务类&＃xff0c;注意是多继承
class Server(ThreadingMixIn, TCPServer): pass#定义请求处理类
class Handler(StreamRequestHandler)&＃xff1a;def handle(self):addr &＃61; self.request.getpeername()print &＃39;Got connection from &＃39;,addrself.wfile.write(&＃39;Thank you for connection&＃39;)server &＃61; Server((&＃39;&＃39;, 1234), Handler) #实例化服务类
server.serve_forever() #开启服务