[Python] 网络编程(Socket)

1. Socket基础

客户端与服务器连接有两种方式：TCP和UDP，TCP是面向连接的方式(三次握手、四次挥手等），可靠但耗资源，而UDP采用无连接方式，不可靠但速度快。这里面的学问很多，但大部分人知道这些就足够了

2. 一个简单的TCP例子（阻塞方式）

不管是Python还是其它语言，Socket编程几乎都有一个固定模板，下面看一个简单例子，用于计算阶乘和，比如客户端发送5，服务器端返回5!+4!+3!+2!+1!。

Server端Python代码：

import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('localhost', 21567))
sock.listen(1)
while True:
    print 'waiting for connecting...'
    connection,address = sock.accept()
    print '...connected from: %s:%i'%(address[0],address[1])
    while True:
        data = connection.recv(1024)
        if not data:
            break
        result = 0
        for i in range(1,int(data)+1):
            result = result + reduce(lambda x,y:x*y,range(1,i+1))
        connection.send('the result is %i'%result)
    connection.close()
sock.close()

下面是该段代码的解释：

首先，实例化一个socket对象，需要三个参数，第一个是地址族（一般都是AF_INET），第二个参数指定连接方式（SOCK_STREAM表示TCP方式，SOCK_DGRAM表示UDP方式），第三个参数定义使用的协议。

然后，绑定IP地址和端口，开启监听，并设置等待连接的队列长度。

服务器端是用accept()方法接受客户端，采用阻塞方式，即如何没有客户端连上来，将会一直阻塞等待。

一旦接收到客户端请求，就可以用recv()方法接受数据，对数据进行处理之后，再利用send()方法返回给客户端。

Client端Python代码：

import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('localhost', 21567))
data = '5'
sock.send(data)
receivedData = sock.recv(1024)
print receivedData
sock.close()

客户端代码非常简单，首先也是实例化一个socket对象，然后和服务器端建立连接，发送数据，接受服务器端返回的数据

3. 分叉(forking)和线程(threading)

上面服务器端实现有个很大问题，就是无法实现并发，一次只能处理一个客户端请求，在高并发的情况下，客户端等待事件会很长，因此在实际的服务器端代码，必须能够支持并发执行。

分叉和线程就是用来解决并发问题，利用Python中的SocketServer模块能很方便实现。

1）分叉

所谓分叉，就是每当有客户端请求时，就创建一个子进程，由子进程处理客户端请求，而父进程继续监听，这样就能处理并发请求了，多进程有个缺点就是比较耗资源。

Server端代码如下：

from SocketServer import TCPServer, ForkingMixIn, StreamRequestHandler

class Server(ForkingMixIn, TCPServer):
    pass
class Handler(StreamRequestHandler):
    def handle(self):
        while True:
            data = self.request.recv(1024)
            if not data:
                break
            result = 0
            for i in range(1,int(data)+1):
                result = result + reduce(lambda x,y:x*y,range(1,i+1))
            self.request.send('the result is %i'%result)
        
server = Server(('localhost', 21567), Handler)
server.serve_forever()

2）多线程

线程是轻量级的进程，所以资源消耗比较少，但它也带来另一个比较棘手的问题，就是共享资源的同步问题。

Server端代码如下：

from SocketServer import TCPServer, ThreadingMixIn, StreamRequestHandler

class Server(ThreadingMixIn, TCPServer):
    pass
class Handler(StreamRequestHandler):
    def handle(self):
        while True:
            data = self.request.recv(1024)
            if not data:
                break
            result = 0
            for i in range(1,int(data)+1):
                result = result + reduce(lambda x,y:x*y,range(1,i+1))
            self.request.send('the result is %i'%result)
        
server = Server(('localhost', 21567), Handler)
server.serve_forever()

4. 异步IO方式(select和poll)

所谓异步IO就是通过时间片轮转方式来为几个连接提供服务，看起来像是同时处理几个连接。代码上会复杂一些，但性能上要比多进程和多线程好。

poll比select的伸缩性要好，但只能在Unix系统中使用，无法在Windows上使用。

对异步IO的处理机制不太明白，代码看起来也很复杂，留着以后再深入理解吧，具体可参考这篇技术博客。

http://www.cnblogs.com/coser/archive/2012/01/06/2315216.html