pythonsocket编程步骤_socket编程各步骤作用简述之python版

python的标准库里面自带了socket模块，直接可以导入，连接方式和其它编程语言基本也是一样的，因为初学socket编程所以每一步具体起到什么作用还不是很明确，而网上基本都是直接代码，大同小易；只有自己试了几次才知道。来看一下比喻的socket连接图：

基本上一个程序对应一个端口，一个线程监听一个socket消息。正常单线程时，有一个请求连接发来，直接就是由唯一的主线程来监听，然后发送消息、接收消息，此时若有其它请求来时，则不会处理只能在请求队列等待，当请求队列已满时则不会再接收请求，直接返回错误。当第一个请求连接处理完事情后，调用了close方法把客户端连接断开后，才开始读取请求队列里最早的请求，此时请求队列不是满的，将可以继续接收请求并排队等待被处理。

[python] view plain copy

from socket import *

from time import ctime

tcpSerSock = socket(AF_INET, SOCK_STREAM) #建立一个服务器socket对象

tcpSerSock.bind(('localhost', 21567)) #设置服务器socket对象的参数

tcpSerSock.listen(5) #设置服务器socket的请求队列长度

while True:

print 'waiting for connection.....'

tcpCliSock, addr = tcpSerSock.accept() ##开始监听服务器socket端口，可以有多个线程来一起监控

print '...conneced from:', addr

while True:

data = tcpCliSock.recv(1024) #接收客户端消息

if not data:

break

tcpCliSock.send('[%s] %s' % (ctime(), data)) #向客户端发送消息

tcpCliSock.close() ##关闭客户端socket的链接

而当不是单线程时，就会有多个线程监听同一个端口，当有连接来时优先级最高的线程将会监听到请求并开始处理，此时有第二个请求来时，再次有优先级最高的线程来监控并处理请求，直到所有线程都用完了，才开始往优先级最高的线程监听队列里插入请求。【适用于短连接，如浏览器】

[python] view plain copy

#!/usr/bin/env python

#encoding: utf-8

import socket, sys, threading, ctime

SERVER = '127.0.0.1' #主机IP

PORT = 8080 #端口号

MAXTHREADS = 10

RECVBUFLEN = 1024

class Checker(threading.Thread):

def __init__(self,socket,num):

threading.Thread.__init__(self)

self.socket = socket

self.num = num

print 'thread started!'

def run(self):

while True:

self.socket.listen(2)

print 'waiting for connection.....'

cs,address = self.socket.accept()

print '...conneced from:', address

while True:

data = cs.recv(1024)

if not data:

break

cs.send('[%s] %s' % (ctime(), data))

cs.close()

self.socket.close()

class authServer(object):

def __init__(self):

self.socket = None

def run(self):

self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

self.socket.bind((SERVER,PORT))

i = 0

chkerlist = []

while i

chker = Checker(self.socket,i)

chker.start()

i = i + 1

chkerlist.append(chker)

for chker in chkerlist:

chker.join()

if __name__ == '__main__':

asvr = authServer()

asvr.run()

上述多线程情况是设置了固定数目的线程，而实际情况中我们经常遇到的情况是不知道会有多少请求，那么就会用一个线程监听，每次监听到请求后新起一个线程，这样有多少请求就会起多少线程，不需要预先设置线程数了。当然如果愿意是可以控制一个数量的【适用于长连接，如qq】

[python] view plain copy

#!/usr/bin/env python

#encoding: utf-8

import socket, threading

from time import ctime

SERVER = '127.0.0.1' #主机IP

PORT = 8080 #端口号

MAXTHREADS = 10

RECVBUFLEN = 1024

class ComunicateServer(threading.Thread):

def __init__(self, clientsocket, address, num):

threading.Thread.__init__(self)

self.socket = clientsocket

self.num = num

self.address = address

print 'New thread [%d] started!' % self.num

def run(self):

while True:

data = self.socket.recv(1024)

if not data:

break

self.socket.send('[%s] %s %s' % (ctime(), data, self.address))

self.socket.close()

class ListenServer(threading.Thread):

def __init__(self):

threading.Thread.__init__(self)

self.socket = None

print 'Start Listen....'

def run(self):

self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

self.socket.bind((SERVER,PORT))

self.socket.listen(2)

num = 1

while True:

cs,address = self.socket.accept()

comser = ComunicateServer(cs, address, num)

comser.start()

num += 1

print 'Listen Next...'

self.socket.close()

if __name__ == '__main__':

asvr = ListenServer()

asvr.start()

asvr.join()

至此，socket服务端的程序基本功能的结构就这样了，复杂的内容都是在这个基础上构建的，用户数量多的时候就会分多个服务器去管理和维护客户端的链接。有设置专门认证的服务器，有专门保存客户端链接的服务器，有专门写数据库的服务器，还有专门进行各服务器控制的中心服务器。还可以有域的概念，不同域对应不同的城市或区域，保证各地服务体验是一样的，这个域类似于邮件服务器的域。

[python] view plain copy

客户端实验代码

from socket import *

tcpCliSock = socket(AF_INET, SOCK_STREAM)

tcpCliSock.connect(('localhost', 8080))

while True:

data = raw_input('> ')

if not data:

break

tcpCliSock.send(data)

data = tcpCliSock.recv(1024)

if not data:

break

print data

tcpCliSock.close()

总结,对于为什么之前没有深刻的认识这个问题，发现主要还是在对线程的理解有偏差，而socket的编程基本是离不开线程的，所以想编写好socket程序，不仅要熟悉socket及网络相关的知识，还需要学习多线程乃至多进程的知识。