socket
直接切入正题吧，首先，socket编程是分为两个部分，一个客户端，一个服务器端，服务器需要监听在一个端口上，而客户端需要连接这个端口。服务器端和客户端通过send和recv函数去实现。
首先，呈现一个超级简单的socket通信的python代码。
服务器端：
#!/usr/bin/python
# -*- coding:utf-8 -*-
import socket
ip_port=('127.0.0.1',9000)
sock = socket.socket() #获得一个监听套接字
sock.bind(ip_port) #绑定到一个IP地址和端口上
sock.listen(1) #监听这个套接字，并且只接受1个
conn,address = sock.accept() #接受客户端的连接请求，并返回连接套接字和客户端的IP
conn.send('hello !') #向连接套接字的对方发送数据
conn.close() #关闭这个连接套接字
客户端：
#!/usr/bin/python
# -*- coding:utf-8 -*-
import socket
ip_port=('127.0.0.1',9000)
client = socket.socket() #创建一个套接字
client.connect(ip_port) #连接目标IP的目标端口
data = client.recv(1024) #返回接收到的数据
print data
但是上述的例子很简单，简单到客户端一连接服务器端，全部程序就全运行完了，也就是说服务器只能接受一次连接。那怎么让通讯循环起来呢？
下面的是改进后的。
服务器端：
#!/usr/bin/python
# -*- coding:utf-8 -*-
import socket
ip_port=('127.0.0.1',9000)
sock = socket.socket() #获得一个监听套接字
sock.bind(ip_port) #绑定到一个IP地址和端口上
sock.listen(3) #监听这个套接字，并且只接受1个
while True:
conn,address = sock.accept()
conn.send('What Can I do for you?')
while True:
data = conn.recv(1024)
print data
tmp = raw_input('server :')
conn.send(tmp)
if tmp == 'exit' or data == 'exit':
conn.close()
break
sock.close()
客户端：
#!/usr/bin/python
# -*- coding:utf-8 -*-
import socket
ip_port=('127.0.0.1',9000)
client = socket.socket() #创建一个套接字
client.connect(ip_port) #连接目标IP的目标端口
while True:
print client.recv(1024)
tmp = raw_input("client :")
client.send(tmp)
if tmp == "exit":
client.close()
break
改进后的代码，服务器端可以循环与客户端对话，而且，服务器端可以处理完一个客户的请求后可以再接受下一个，但是这还有一个问题，那就是服务器端不能同时接受2个及以上的客户端同时访问服务。
下面稍微解释一下上面的代码。
sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM,0)
参数一：AF_INET ipv4
参数二：SOCK_STREAM 流式套接字（TCP）， 其他的分别是SOCK_DGRAM（UDP），SOCK_RAW（原始套接字），其中原始套接字可以处理ICMP，IGMP等网络报文。
参数三：与特定的地址家族相关的协议。
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])
最多可以接收的数量。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()
套接字的文件描述符
下来演示一个改进版的socket通信。改进的地方就是利用了多线程的技术，可以多线程的去连接服务器端。主要是改动的是服务器端。
#!/usr/bin/python
# -*- coding:utf-8 -*-
import SocketServer
class MyServer(SocketServer.BaseRequestHandler):
def handle(self):
conn = self.request
conn.send('Welcome to North,What can I do for you')
while True:
data = conn.recv(1024)
if data == 'exit':
conn.close()
break
else:
print 'client <'+str(self.client_address)+'>:'+data
tmp = raw_input("Server : ")
conn.send(tmp)
if __name__ == '__main__':
ip_port = ('127.0.0.1',9000)
server = SocketServer.ThreadingTCPServer(ip_port,MyServer)
server.serve_forever()
这次使用的是SocketServer这个模块。可以直接实现多线程的服务器。
下面去探索一下这个模块。
1.SocketServer.ThreadingTCPServer(ip_port,MyServer) 这是实例化了一个类。
看看这个类
在类里面什么也没干，只是继承了ThreadingMixTn和TCPServer这两个类。
那么接着先看看TCPServer这个类。
class TCPServer(BaseServer):
address_family = socket.AF_INET
socket_type = socket.SOCK_STREAM
request_queue_size = 5
allow_reuse_address = True
def __init__(self, server_address, RequestHandlerClass, bind_and_activate=True):
"""Constructor. May be extended, do not override."""
BaseServer.__init__(self, server_address, RequestHandlerClass)
self.socket = socket.socket(self.address_family,
self.socket_type)
if bind_and_activate:
self.server_bind()
self.server_activate()
def server_bind(self):
"""Called by constructor to bind the socket.
May be overridden.
"""
if self.allow_reuse_address:
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.socket.bind(self.server_address)
self.server_address = self.socket.getsockname()
def server_activate(self):
"""Called by constructor to activate the server.
May be overridden.
"""
self.socket.listen(self.request_queue_size)
def server_close(self):
"""Called to clean-up the server.
May be overridden.
"""
self.socket.close()
def fileno(self):
"""Return socket file number.
Interface required by select().
"""
return self.socket.fileno()
def get_request(self):
"""Get the request and client address from the socket.
May be overridden.
"""
return self.socket.accept()
def shutdown_request(self, request):
"""Called to shutdown and close an individual request."""
try:
#explicitly shutdown. socket.close() merely releases
#the socket and waits for GC to perform the actual close.
request.shutdown(socket.SHUT_WR)
except socket.error:
pass #some platforms may raise ENOTCONN here
self.close_request(request)
def close_request(self, request):
"""Called to clean up an individual request."""
request.close()
这个类又继承了BaseServer这个类。
这个类先看一下__init__这个方法吧。
def __init__(self, server_address, RequestHandlerClass):
"""Constructor. May be extended, do not override."""
self.server_address = server_address
self.RequestHandlerClass = RequestHandlerClass
self.__is_shut_down = threading.Event()
self.__shutdown_request = False
最开始传入的参数就放入了server_address和RequesHandlerClass。
再回到刚刚的那个TCPServer这个类里面。
def __init__(self, server_address, RequestHandlerClass, bind_and_activate=True):
"""Constructor. May be extended, do not override."""
BaseServer.__init__(self, server_address, RequestHandlerClass)
self.socket = socket.socket(self.address_family,
self.socket_type)
if bind_and_activate:
self.server_bind()
self.server_activate()
这个方法先是将BaseServer初始化了一下。然后创建了一个监听套接字。采用的是流式套接字和IPV4。
再做了绑定操作和监听操作。
self.server_bind() 和 self.server_activate()
好了，再看看ThreadingMixIn这个类。
这个类十分简单。
class ThreadingMixIn:
"""Mix-in class to handle each request in a new thread."""
# Decides how threads will act upon termination of the
# main process
daemon_threads = False
def process_request_thread(self, request, client_address):
"""Same as in BaseServer but as a thread.
In addition, exception handling is done here.
"""
try:
self.finish_request(request, client_address)
self.shutdown_request(request)
except:
self.handle_error(request, client_address)
self.shutdown_request(request)
def process_request(self, request, client_address):
"""Start a new thread to process the request."""
t = threading.Thread(target = self.process_request_thread,
args = (request, client_address))
t.daemon = self.daemon_threads
t.start()
这个类里的定义的两个方法会在BaseServer里的serve_forever() 里被调用。
说来说去可能有点晕了。我画了一个图。
最后说一下这个重要的serve_forever方法。
def serve_forever(self, poll_interval=0.5):
"""Handle one request at a time until shutdown.
Polls for shutdown every poll_interval seconds. Ignores
self.timeout. If you need to do periodic tasks, do them in
another thread.
"""
self.__is_shut_down.clear()
try:
while not self.__shutdown_request:
# XXX: Consider using another file descriptor or
# connecting to the socket to wake this up instead of
# polling. Polling reduces our responsiveness to a
# shutdown request and wastes cpu at all other times.
r, w, e = _eintr_retry(select.select, [self], [], [],
poll_interval)
if self in r:
self._handle_request_noblock()
finally:
self.__shutdown_request = False
self.__is_shut_down.set()
越写越发现这个SocketServer好麻烦，一言两语说不清，那从开一个博客说吧，这个就先说到这里。
