TCP:可靠的面向连接的协议,传输效率低,全双工通信,流数据传输。运用:web浏览器,电子邮件,文件传输程序
UDP:不可靠的,无连接的服务,传输效率高,面向数据包的传输,只能发短消息。运用:dns , 视频流 ,IP语音(VoIP)
根据MTU最大传输单元为1500(普遍),再减去报头,报尾,所以udp传输最多是1470余
tcp和udp的对比
tcp:交换数据前,必须先经过三次握手,tcp提供超时重发,丢弃重复数据,有检验数据,流控制功能
数据传输必须先要得到对方的确认,有时候网络问题,会造成数据的多次发送,断开必须四次挥手
udp:用户数据报协议,它只负责将数据传输出去,但是能不能到达目的地,它不会管,没有握手和挥手的原因,传输速度就会很快
socket
socket层,是应用层与tcp/ip 协议簇中间的软件抽象层,它是一组接口
1 基于tcp的socket
服务端:
conn,client_addr=sk.accept()
conn: <socket.socket fd=520, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9000), raddr=('127.0.0.1', 54805)>
client_addr:('127.0.0.1', 54805)
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import socket sk=socket.socket() #默认使用tcp模式 sk.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #表示重用IP和端口,写在bind之前 sk.bind(('127.0.0.1',9000)) #绑定ip和端口,必须是一个元组, sk.listen() #监听,在pycharm3.4之后的版本,里面可以不写,要写的话,表示监听的链接数 conn,addr=sk.accept() #接收客户端链接 ,经历了 3 次握手 ret=conn.recv(1024) #接收客户端信息 print(ret) conn.send(b'hello') #向客户端发送信息 conn.close() #关闭客户端套接字,经历了 4 次挥手 sk.close() #关闭服务器套接字
客户端:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import socket sk=socket.socket() sk.connect(('127.0.0.1',9000)) ret=sk.recv(1024).decode('utf-8') sk.send('hello'.encode('utf-8')) sk.close()
对于一个tcp而言,客户端和server是一直被占用的,换句话说链接是阻塞的,其他客户端插不进去
2 基于udp协议的socket
服务端
msg,client_addr=server.recvfrom(1024) # 前面是信息,后面是客户端地址,例如:b'hello' ('127.0.0.1', 60936)
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import socket lst = {'egon': '\033[1;31m', 'yuan': '\033[1;34m'} #不同的人不同颜色 sk = socket.socket(type=socket.SOCK_DGRAM) sk.bind(('127.0.0.1', 9090)) while True: msg, client_addr = sk.recvfrom(1024) # udp协议不用建立链接 name, mesg = msg.decode('utf-8').split(':') color = lst.get(name.strip(), '') print('%s%s\033[0m' % (color, msg.decode('utf-8'))) inp = input('>>>') sk.sendto(inp.encode('utf-8'), client_addr) sk.close()
客户端
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import socket sk = socket.socket(type=socket.SOCK_DGRAM) name = input('请输入名字: ') while True: inp = input('请输入发送内容: ') sk.sendto(('%s : %s' % (name, inp)).encode('utf-8'), ('127.0.0.1', 9090)) msg, addr = sk.recvfrom(1024) print(msg.decode('utf-8')) sk.close()
客户端和服务端可以不分先后的开启,udp模式必须先接收信息,因为它必须先要收到地址才能发送信息
3 socket的参数详解
socket.socket(family=AF_INET,type=SOCK_STREAM,proto=0,fileno=None)
创建socket对象的参数说明:
family | 地址系列应为AF_INET(默认值),AF_INET6,AF_UNIX,AF_CAN或AF_RDS。 (AF_UNIX 域实际上是使用本地 socket 文件来通信) |
type | 套接字类型应为SOCK_STREAM(默认值),SOCK_DGRAM,SOCK_RAW或其他SOCK_常量之一。 SOCK_STREAM 是基于TCP的,有保障的(即能保证数据正确传送到对方)面向连接的SOCKET,多用于资料传送。 SOCK_DGRAM 是基于UDP的,无保障的面向消息的socket,多用于在网络上发广播信息。 |
proto | 协议号通常为零,可以省略,或者在地址族为AF_CAN的情况下,协议应为CAN_RAW或CAN_BCM之一。 |
fileno | 如果指定了fileno,则其他参数将被忽略,导致带有指定文件描述符的套接字返回。 与socket.fromfd()不同,fileno将返回相同的套接字,而不是重复的。 这可能有助于使用socket.close()关闭一个独立的插座。 |
socketserver
socketserver内部使用io多路复用,以及多线程和多进程,从而实现并发处理多个客户端请求的socket服务端
即:每个客户端请求连接到服务器时,socket服务端都会在服务器端创建一个线程或者进程,负责处理对应的客户端请求
它的基础使用的时socket
Threading TCPServer实现的是:socket服务器内部为每个client创建一个线程
下面查看一下其内部的部分代码
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
class BaseRequestHandler: def __init__(self, request, client_address, server): self.request = request self.client_address = client_address self.server = server self.setup() try: self.handle() finally: self.finish() def setup(self): pass def handle(self): pass def finish(self): pass
所以使用socketserver有其固定的部分
服务端: import socketserver class MyServer(socketserver.BaseRequestHandler): def handle(self): # print(self.request) server = socketserver.ThreadingTCPServer((ip,port),MyServer) server.serve_forever()
下面来看其用法:
服务端:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import socketserver class Myserver(socketserver.BaseRequestHandler): def handle(self): while True: print(self.request) data=input('>>>').strip() self.request.send(data.encode('utf-8')) print(self.request.recv(1024)) if __name__ == '__main__': server=socketserver.ThreadingTCPServer(('127.0.0.1',9000),Myserver) server.serve_forever()
客户端
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import socket sk=socket.socket() sk.connect(('127.0.0.1',9000)) while True: print(sk.recv(1024)) inp=input('>>>').encode('utf-8') sk.send(inp) sk.close()
接下来:先启动服务端,再启动两个客户端 其结果如下:
说明:启动客户端后,再启动一个客户端,服务器先发一条信息,这个客户端接到信息,接着启动第二个客户端
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
服务端的情况 <socket.socket fd=428, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9000), raddr=('127.0.0.1', 49750)> >>>who b'client2' <socket.socket fd=512, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9000), raddr=('127.0.0.1', 49753)> >>>1 b'client1 -1' <socket.socket fd=428, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9000), raddr=('127.0.0.1', 49750)> >>>1 b'2' <socket.socket fd=512, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9000), raddr=('127.0.0.1', 49753)> >>>hehe b'client' <socket.socket fd=428, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9000), raddr=('127.0.0.1', 49750)> >>>3 b'haohao' <socket.socket fd=512, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9000), raddr=('127.0.0.1', 49753)> >>>
result: 信息可以输入的顺序:先服务器输入信息,第一个客户端接收,发送信息,接着回到服务端,服务端再发一条信息,第二个客户端收到,再回到服务端,周而复始。。。
下面演变为:让两个客户端通信,设置为client先发信息,接着client2再发
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
服务器端: import socketserver l=[] class Myserver(socketserver.BaseRequestHandler): def handle(self): l.append(self.request) print(l) while True: data=l[0].recv(1024) l[1].send(data) data2=l[1].recv(1024) l[0].send(data2) if __name__ == '__main__': server=socketserver.ThreadingTCPServer(('127.0.0.1',9000),Myserver) server.serve_forever() 客户端 client import socket sk=socket.socket() sk.connect(('127.0.0.1',9000)) while True: inp=input('>>>').encode('utf-8') sk.send(inp) data=sk.recv(1024).decode('utf-8') print(data) sk.close() 客户端 client2 import socket sk=socket.socket() sk.connect(('127.0.0.1',9000)) while True: print(sk.recv(1024).decode('utf-8')) inp=input('>>>').encode('utf-8') sk.send(inp) sk.close()
结果显示:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
服务端: [<socket.socket fd=588, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9000), raddr=('127.0.0.1', 50089)>] [<socket.socket fd=588, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9000), raddr=('127.0.0.1', 50089)>, <socket.socket fd=608, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9000), raddr=('127.0.0.1', 50091)>] 客户端client >>>nihao nihao >>>你是谁 我是client2 >>>幸会,我这是client 客户端 client2 nihao >>>nihao 你是谁 >>>我是client2 幸会,我这是client >>>
socketserver的最终解释:server可以接收多个客户端,会根据先后顺序记录下面,server端发信息,按照客户端连接的顺序来的.
server -->client
client --->server
server --->client2
client2 --->server
server---->client 。。。。。周而复始