1.单进程服务器
from socket import * serSocket = socket(AF_INET, SOCK_STREAM) # 重复使用绑定的信息 serSocket.setsockopt(SOL_SOCKET, SO_REUSEADDR , 1) localAddr = (‘‘, 7788) serSocket.bind(localAddr) serSocket.listen(5) while True: print(‘-----主进程，，等待新客户端的到来------‘) newSocket,destAddr = serSocket.accept() print(‘-----主进程，，接下来负责数据处理[%s]-----‘%str(destAddr)) try: while True: recvData = newSocket.recv(1024) if len(recvData)>0: print(‘recv[%s]:%s‘%(str(destAddr), recvData)) else: print(‘[%s]客户端已经关闭‘%str(destAddr)) break finally: newSocket.close() serSocket.close()
总结
- 同一时刻只能为一个客户进行服务，不能同时为多个客户服务
- 类似于找一个“明星”签字一样，客户需要耐心等待才可以获取到服务
- 当recv接收数据时，返回值为空，即没有返回数据，那么意味着客户端已经调用了close关闭了；因此服务器通过判断recv接收数据是否为空 来判断客户端是否已经下线
2.如何实现并发的？
from socket import * from multiprocessing import Pool serSocket = socket(AF_INET, SOCK_STREAM) serSocket.setsockopt(SOL_SOCKET, SO_REUSEADDR , 1) #1表示端口可以充分使用，不会出现already used localAddr = (‘‘, 7788) serSocket.bind(localAddr) serSocket.listen(5) def dealWithClient(newSocket,destAddr): while True: recvData = newSocket.recv(1024) if len(recvData)>0: print(‘recv[%s]:%s‘%(str(destAddr), recvData)) else: print(‘[%s]客户端已经关闭‘%str(destAddr)) break newSocket.close() def main(): while True: print(‘-----主进程，，等待新客户端的到来------‘) newSocket,destAddr = serSocket.accept() print(‘-----主进程，，接下来负责数据处理[%s]-----‘%str(destAddr)) client = Pool(targetc=dealWithClient,args=(newSocket,destAddr)) client.start() newSocket.close() #新的进程以及有套接字，此时的套接字，不需要了 serSocket.close() if __name__ == "__main__": main()
3. 多进程服务器：进程占用的资源多
from socket import * from multiprocessing import * from time import sleep # 处理客户端的请求并为其服务 def dealWithClient(newSocket,destAddr): while True: recvData = newSocket.recv(1024) if len(recvData)>0: print(‘recv[%s]:%s‘%(str(destAddr), recvData)) else: print(‘[%s]客户端已经关闭‘%str(destAddr)) break newSocket.close() def main(): serSocket = socket(AF_INET, SOCK_STREAM) serSocket.setsockopt(SOL_SOCKET, SO_REUSEADDR , 1) localAddr = (‘‘, 7788) serSocket.bind(localAddr) serSocket.listen(5) try: while True: print(‘-----主进程，，等待新客户端的到来------‘) newSocket,destAddr = serSocket.accept() print(‘-----主进程，，接下来创建一个新的进程负责数据处理[%s]-----‘%str(destAddr)) client = Process(target=dealWithClient, args=(newSocket,destAddr)) client.start() #因为已经向子进程中copy了一份（引用），并且父进程中这个套接字也没有用处了 #所以关闭 newSocket.close() finally: #当为所有的客户端服务完之后再进行关闭，表示不再接收新的客户端的链接 serSocket.close() if __name__ == ‘__main__‘: main()
- 通过为每个客户端创建一个进程的方式，能够同时为多个客户端进行服务
- 当客户端不是特别多的时候，这种方式还行，如果有几百上千个，就不可取了，因为每次创建进程等过程需要好较大的资源
- 写时copy：进程先调用，不到万不得已，才copy一份
4.多线程服务器：线程共用同一份进程资源
#coding=utf-8 from socket import * from threading import Thread from time import sleep # 处理客户端的请求并执行事情 def dealWithClient(newSocket,destAddr): while True: recvData = newSocket.recv(1024) if len(recvData)>0: print(‘recv[%s]:%s‘%(str(destAddr), recvData)) else: print(‘[%s]客户端已经关闭‘%str(destAddr)) break newSocket.close() def main(): serSocket = socket(AF_INET, SOCK_STREAM) serSocket.setsockopt(SOL_SOCKET, SO_REUSEADDR , 1) localAddr = (‘‘, 7788) serSocket.bind(localAddr) serSocket.listen(5) try: while True: print(‘-----主进程，，等待新客户端的到来------‘) newSocket,destAddr = serSocket.accept() print(‘-----主进程，，接下来创建一个新的进程负责数据处理[%s]-----‘%str(destAddr)) client = Thread(target=dealWithClient, args=(newSocket,destAddr)) client.start() #因为线程中共享这个套接字，如果关闭了会导致这个套接字不可用， #但是此时在线程中这个套接字可能还在收数据，因此不能关闭 #newSocket.close() finally: serSocket.close() if __name__ == ‘__main__‘: main()
- 模拟tcp客户端，多线程可以连接
5.单进程服务器：非阻塞模式
#将套接字设置为非堵塞 #设置为非堵塞后，如果accept时，恰巧没有客户端connect，那么accept会 #产生一个异常，所以需要try来进行处理 serSocket.setblocking(False)
from socket import * #1.创建socket serSocket = socket(AF_INET, SOCK_STREAM) #2. 绑定本地ip以及port localAddr = (‘‘, 7788) serSocket.bind(localAddr) #3. 让这个socket 变为非堵塞 serSocket.setblocking(False) #4. 将socket变为监听（被动）套接字 serSocket.listen(100) # 用来保存所有已经连接的客户端的信息 clientAddrList = [] while True: #等待一个新的客户端的到来（即完成3次握手的客户端） try: clientSocket,clientAddr = serSocket.accept() except: pass else: print("一个新的客户端到来：%s"%str(clientAddr)) clientSocket.setblocking(False) clientAddrList.append((clientSocket,clientAddr)) for clientSocket,clientAddr in clientAddrList: try: recvData = clientSocket.recv(1024) except: pass else: if len(recvData)>0: print("%s:%s"%(str(clientAddr), recvData)) else: clientSocket.close() clientAddrList.remove((clientSocket, clientAddr)) print("%s 已经下线"%str(clientAddr))
IO多路复用
6.select版-TCP服务器:最多1024
import select import socket import sys server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server.bind((‘‘, 7788)) server.listen(5) inputs = [server, sys.stdin] running = True while True: # 调用 select 函数，阻塞等待 readable, writeable, exceptional = select.select(inputs, [], []) # 数据抵达，循环 for sock in readable: # 监听到有新的连接 if sock == server: conn, addr = server.accept() # select 监听的socket inputs.append(conn) # 监听到键盘有输入 elif sock == sys.stdin: cmd = sys.stdin.readline() running = False break # 有数据到达 else: # 读取客户端连接发送的数据 data = sock.recv(1024) if data: sock.send(data) else: # 移除select监听的socket inputs.remove(sock) sock.close() # 如果检测到用户输入敲击键盘，那么就退出 if not running: break server.close()
总结
优点
select目前几乎在所有的平台上支持，其良好跨平台支持也是它的一个优点。
缺点
select的一个缺点在于单个进程能够监视的文件描述符的数量存在最大限制，在Linux上一般为1024，可以通过修改宏定义甚至重新编译内核的方式提升这一限制，但是这样也会造成效率的降低。
一般来说这个数目和系统内存关系很大，具体数目可以cat /proc/sys/fs/file-max察看。32位机默认是1024个。64位机默认是2048.
对socket进行扫描时是依次扫描的，即采用轮询的方法，效率较低。
当套接字比较多的时候，每次select()都要通过遍历FD_SETSIZE个Socket来完成调度，不管哪个Socket是活跃的，都遍历一遍。这会浪费很多CPU时间。
7.epoll版-TCP服务器
1. epoll的优点：
- 没有最大并发连接的限制，能打开的FD(指的是文件描述符，通俗的理解就是套接字对应的数字编号)的上限远大于1024
- 效率提升，不是轮询的方式，不会随着FD数目的增加效率下降。只有活跃可用的FD才会调用callback函数；即epoll最大的优点就在于它只管你“活跃”的连接，而跟连接总数无关，因此在实际的网络环境中，epoll的效率就会远远高于select和poll。
