python socket（三）forking 实现网络并发

在python socket（一）和python socket（二）中服务器都只能一个客户端连接。

我们现在要让服务器实现多个连接。

连接都是从conn，addr = s.accept()开始的，如果把连接写成一个循环，就可以有多个连接啦。

# -*- coding: utf-8 -*-
##
# socket_server
# Created on July 7 2016
# @author:huangpingyi
##
import socket


HOST = ''  # 本地localhost
PORT = 50007
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.bind((HOST, PORT))
s.listen(5)


while True:
       conn,addr = s.accept()#接收连接
       print "Connected by",addr
       while True:
           try:
               data = conn.recv(1024)
               if not data:
                   break
               print "Received",data
               msg = raw_input(">>:").strip()
               if len(msg) == 0:
                   continue
               conn.sendall(msg)
           except socket.error:
               break
       conn.close()

这样就可以一个一个连接不断接收，这样就实现了一个并发。

但是需要一个连接然后结束进行另一个连接，但是服务器端是一直阻塞的，只能一个进行完下一个在进行。服务器处理客户端发出请求时阻塞，没有真正的实现同时为多个客户端服务。

python提供了3中方式：forking（多进程）、threading（多线程）、异步I/O

首先来看看用多进程的方式实现：

在Linux中提供了fork（）函数，一个fork可以创建很多子进程。可以看看fork解析。

启动多个客户端，看看服务器怎样处理。

#! /usr/bin/env python

import os
import socket
import SocketServer
import threading
SERVER_HOST = 'localhost'
SERVER_PORT = 9999
BUF_SIZE = 1024
ECHO_MSG = 'Hello echo server!'

class ForkingClient():
   def __init__(self, ip, port):
       self.sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
       self.sock.connect((ip,port))
   def run(self):
       current_process_id = os.getpid()
       print 'PID %s Sending echo message to the server:"%s"' % (current_process_id,ECHO_MSG)
       sent_data_length = self.sock.send(ECHO_MSG)
       print "Sent : %d characters,so far..." %sent_data_length
       response = self.sock.recv(BUF_SIZE)
       print "PID %s received: %s" %(current_process_id,response)
   def shutdown(self):
       self.sock.close()
class ForkingServerRequestHandler(SocketServer.BaseRequestHandler):
   def handle(self):
       data = 'Hello echo client!'
       current_process_id = os.getpid()
       response = '%s: %s' % (current_process_id,data)
       print "Server sending response : %s" %response
       self.request.send(response)
       return
class ForkingServer(SocketServer.ForkingMixIn,SocketServer.TCPServer,):
      pass

def main():
      server = ForkingServer((SERVER_HOST,SERVER_PORT),ForkingServerRequestHandler)
      ip, port = server.server_address
      server_thread = threading.Thread(target=server.serve_forever)
      server_thread.start()
      print 'Server loop running PID: %s ' % os.getpid()

      client1 = ForkingClient(ip,port)
      client1.run()

      client2 = ForkingClient(ip,port)
      client2.run()

      server.shutdown()
      client1.shutdown()
      client2.shutdown()
      server.socket.close()

if __name__ =='__main__':
     main()

本实验用SocketServer模块提供好的一个类：ForkingMixIn。ForkingMinIn会为每个客户端请求派生一个进程，处理客户端。

首先创建了一个客户端类。

创建了一个ForkingServer类，继承TCPServer和ForkingMixIn类。TCPServer实现了手动完成服务器的操作，例如创建套接字，绑定地址和监听进入的连接。

还有一个处理请求类ForkingServerRequestHandler类，继承SocketServer库提供的BaseRequestHandler类.

在main函数里，用setDeamon（True）设置一个守护线程。

创建两个客户端去请求服务器，可以看见服务器会启用两个进程分别处理客户端的请求。

（注意：recv函数是阻塞函数，如果没有返回值就会一直阻塞，直到连接关闭。可以通过设置一个时间超时settimeout( )来避免recv一直阻塞。

              在python中target一般为一个可调用对象，比如函数，函数对象。args表示函数需要传入的参数）