Python成长之路——socket《一》

最新推荐文章于 2024-05-02 18:46:32 发布

有所为有所不为

最新推荐文章于 2024-05-02 18:46:32 发布

阅读量149

点赞数

分类专栏： Python 文章标签： python socket tcp udp

本文链接：https://blog.csdn.net/changqi008/article/details/89214950

版权

Python 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

什么是socket

Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。

在学习socket之前，我们先来了解下Tcp协议和Udp协议

TCP（Transmission Control Protocol）可靠的、面向连接的协议（eg:打电话）、传输效率低全双工通信（发送缓存&接收缓存）、面向字节流。使用TCP的应用：Web浏览器；电子邮件、文件传输程序。

UDP（User Datagram Protocol）不可靠的、无连接的服务，传输效率高（发送前时延小），一对一、一对多、多对一、多对多、面向报文，尽最大努力服务，无拥塞控制。使用UDP的应用：域名系统 (DNS)；视频流；IP语音(VoIP)。

基于tcp协议上的socket

tcp是基于链接的，必须是先启用服务端，然后在启动客户端去访问服务端

server端

import socket
sk = socket.socket()
# 如果子重启服务端的时候出现 OSError：[Errno 48] Address already in use 
sk.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加
sk.bind(('127.0.0.1',8001))  #把地址绑定到套接字
sk.listen()          #监听链接
conn,addr = sk.accept() #接受客户端链接
ret = conn.recv(1024)  #接收客户端信息
print(ret)       #打印客户端信息
conn.send(b'hi')        #向客户端发送信息
conn.close()       #关闭客户端套接字
sk.close()        #关闭服务器套接字(可选)

client端

import socket
sk = socket.socket()           # 创建客户套接字
sk.connect(('127.0.0.1',8001))    # 尝试连接服务器
sk.send(b'hello!')
ret = sk.recv(1024)         # 对话(发送/接收)
print(ret)
sk.close()            # 关闭客户套接字

通过一个小例子，实现一对一的聊天

server端

import socket
sk = socket.socket()
sk.bind(("127.0.0.1",8080))
sk.listen()
conn,addr = sk.accept()
while True:
    ret = conn.recv(1024).decode('utf-8')
    if ret == 'bye':
        break
    print("\033[31m你有新的消息，请及时处理：\033[0m"+"\033[32m"+ret+"\033[0m")
    info = input("消息回复：").encode("utf-8")
    conn.send(info)
conn.close()
sk.close()

client端

import socket
sk = socket.socket()
sk.connect(("127.0.0.1",8080))
while True:
    info = input("消息发送：").encode("utf-8")
    sk.send(info)
    ret = sk.recv(1024).decode('utf-8')
    print("\033[31m你有新的消息，请及时回复：\033[0m" + "\033[32m" + ret + "\033[0m")
    if ret == 'bye':
        sk.send(b'bye')
        break
sk.close()

基于udp协议上的socket

udp是无链接的，启动服务之后可以直接接受消息，不需要提前建立链接

简单的基本使用

server端

import socket
udp_sk = socket.socket(type=socket.SOCK_DGRAM)   #创建一个服务器的套接字
udp_sk.bind(('127.0.0.1',8050))        #绑定服务器套接字
msg,addr = udp_sk.recvfrom(1024)
print(msg)
udp_sk.sendto(b'hi',addr)                 # 对话(接收与发送)
udp_sk.close()                         # 关闭服务器套接字

client端

import socket
ip_port=('127.0.0.1',8050)
udp_sk=socket.socket(type=socket.SOCK_DGRAM)
udp_sk.sendto(b'hello',ip_port)
back_msg,addr=udp_sk.recvfrom(1024)
print(back_msg.decode('utf-8'),addr)

通过一个小例子，qq聊天

server端

import socket
sk = socket.socket(type=socket.SOCK_DGRAM)
sk.bind(('127.0.0.1',8080))
while True:
    msg,addr = sk.recvfrom(1024)
    print(msg.decode("utf-8"))
    info = input("消息回复：").encode("utf-8")
    sk.sendto(info,addr)
sk.close()

client端

import socket
sk = socket.socket(type=socket.SOCK_DGRAM)
ip_port = ("127.0.0.1",8080)
while True:
    info = input("消息发送：")
    info = ("\033[34m来自用户1的消息： %s \033[0m"%info).encode("utf-8")
    sk.sendto(info,ip_port)
    msg,addr = sk.recvfrom(1024)
    print("\033[34m"+msg.decode('utf-8')+"\033[0m")
sk.close()

client2端

import socket
sk = socket.socket(type=socket.SOCK_DGRAM)
ip_port = ("127.0.0.1",8080)
while True:
    info = input("消息发送：")
    info = ("\033[32m来自用户2的消息： %s \033[0m"%info).encode("utf-8")
    sk.sendto(info,ip_port)
    msg,addr = sk.recvfrom(1024)
    print("\033[32m"+msg.decode('utf-8')+"\033[0m")
sk.close()

socket对象的参数说明

socket.socket(family=AF_INET,type=SOCK_STREAM,proto=0,fileno=None)

参数	说明
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()关闭一个独立的插座。

黏包

黏包现象
基于tcp协议的黏包
server端

#_*_coding:utf-8_*_
from socket import *
import subprocess

ip_port=('127.0.0.1',7070)
BUFSIZE=1024

tcp_sk_ser=socket(AF_INET,SOCK_STREAM)
tcp_sk_ser.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
tcp_sk_ser.bind(ip_port)
tcp_sk_ser.listen(5)

while True:
    conn,addr=tcp_sk_ser.accept()
    print('客户端',addr)
    while True:
        cmd=conn.recv(BUFSIZE)
        if len(cmd) == 0:break
        res=subprocess.Popen(cmd.decode('gbk'),shell=True,stdout=subprocess.PIPE,stdin=subprocess.PIPE,stderr=subprocess.PIPE)
        stderr=res.stderr.read()
        stdout=res.stdout.read()
        conn.send(stderr)
        conn.send(stdout)
conn.close()
tcp_sk_ser.close()

client端

#_*_coding:utf-8_*_
import socket
BUFSIZE=1024
ip_port=('127.0.0.1',7070)

tcp_sk_cli=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=tcp_sk_cli.connect_ex(ip_port)
while True:
    msg=input('>>: ').strip()
    if len(msg) == 0:continue
    if msg == 'quit':break
    tcp_sk_cli.send(msg.encode('gbk'))
    act_res=tcp_sk_cli.recv(BUFSIZE)
    print(act_res.decode('gbk'))
tcp_sk_cli.close()

基于udp协议的黏包
server端

#_*_coding:utf-8_*_
from socket import *
import subprocess

ip_port=('127.0.0.1',7070)
bufsize=1024

udp_sk_ser=socket(AF_INET,SOCK_DGRAM)
udp_sk_ser.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
udp_sk_ser.bind(ip_port)

while True:
    #收消息
    cmd,addr=udp_sk_ser.recvfrom(bufsize)
    print('用户命令----->',cmd)
    #逻辑处理
    res=subprocess.Popen(cmd.decode('utf-8'),shell=True,stderr=subprocess.PIPE,stdin=subprocess.PIPE,stdout=subprocess.PIPE)
    stderr=res.stderr.read()
    stdout=res.stdout.read()
    #发消息
    udp_sk_ser.sendto(stderr,addr)
    udp_sk_ser.sendto(stdout,addr)
udp_sk_ser.close()

client端

from socket import *
ip_port=('127.0.0.1',7070)

bufsize=1024
udp_sk_cli=socket(AF_INET,SOCK_DGRAM)

while True:
    msg=input('>>: ').strip()
    udp_sk_cli.sendto(msg.encode('gbk'),ip_port)
    err,addr=udp_sk_cli.recvfrom(bufsize)
    out,addr=udp_sk_cli.recvfrom(bufsize)
    if err:
        print('error : %s'%err.decode('gbk'),end='')
    if out:
        print(out.decode('gbk'), end='')
udp_sk_cli.close()

res=subprocess.Popen(cmd.decode('gbk'),shell=True,stderr=subprocess.PIPE,stdin=subprocess.PIPE,stdout=subprocess.PIPE)
# res的结果的编码是以当前的系统为准，以windows为例，那么res.stdout.read()读出来的就是bgk编码，在接收端需要用gbk进行解码
# 且只能从管道你读出一次结果

同时执行多条命令之后，得到的结果很可能只有一部分，在执行其他命令的时候又接收到之前执行的另一部分结果，这种显现出来的就是黏包

总结：只有tcp有黏包现象，udp不会黏包

黏包的原因
tcp协议中数据的传输以及tcp协议的拆包机制

当发送端的缓冲区的长度大于网卡的MTU时，tcp会将数据拆成几个包发送出去
MTU是Maximum Transmission Unit的缩写。意思是网络上传送的最大数据包。MTU的单位是字节。大部分网络设备的MTU都是1500。如果本机的MTU比网关的MTU大，大的数据包就会被拆开来传送，这样会产生很多数据包碎片，增加丢包率，降低网络速度。

基于tcp协议特点的黏包现象成因

发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据
也就是说，应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。
而UDP是面向消息的协议，每个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据，这一点和TCP是很不同的。
怎样定义消息呢？可以认为对方一次性write/send的数据为一个消息，需要明白的是当对方send一条信息的时候，无论底层怎样分段分片，TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。

例如基于tcp的套接字客户端往服务端上传文件，发送时文件内容是按照一段一段的字节流发送的，在接收方看了，根本不知道该文件的字节流从何处开始，在何处结束
此外，发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。

UDP不会发生黏包

UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。
不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。即面向消息的通信是有消息保护边界的。
对于空消息：tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），也可以被发送，udp协议会帮你封装上消息头发送过去。
不可靠不黏包的udp协议：udp的recvfrom是阻塞的，一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的数据就算完成,若是y;x数据就丢失，这意味着udp根本不会粘包，但是会丢数据，不可靠。

会发生黏包的两种情况
发送方的缓存机制

发送端需要等缓冲区满才发送出去，造成黏包（发送数据时间间隔很短，数据了很小，会合到一起，产生黏包）

server端

#_*_coding:utf-8_*_
from socket import *
ip_port=('127.0.0.1',8080)
tcp_socket_server=socket(AF_INET,SOCK_STREAM)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(5)
conn,addr=tcp_socket_server.accept()
data1=conn.recv(10)
data2=conn.recv(10)
print('----->',data1.decode('utf-8'))
print('----->',data2.decode('utf-8'))
conn.close()

client端

#_*_coding:utf-8_*_
import socket
BUFSIZE=1024
ip_port=('127.0.0.1',8080)

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(ip_port)

s.send('hello'.encode('utf-8'))
s.send('world'.encode('utf-8'))

接收方的缓存机制

接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）

server端

#_*_coding:utf-8_*_
from socket import *
ip_port=('127.0.0.1',8080)

tcp_socket_server=socket(AF_INET,SOCK_STREAM)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(5)

conn,addr=tcp_socket_server.accept()

data1=conn.recv(2) #一次没有收完整
data2=conn.recv(10)#下次收的时候,会先取旧的数据,然后取新的

print('----->',data1.decode('utf-8'))
print('----->',data2.decode('utf-8'))

conn.close()

client端

#_*_coding:utf-8_*_
import socket
BUFSIZE=1024
ip_port=('127.0.0.1',8080)

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(ip_port)

s.send('hello world'.encode('utf-8'))

总结

黏包现象只发生在tcp协议中：
1.从表面上看，黏包问题主要是因为发送方和接收方的缓存机制、tcp协议面向流通信的特点。
2.实际上，主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的

更多内容转Python成长之路——socket《一》

有所为有所不为

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Python成长之路——socket《一》

什么是socketSocket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。在学习socket之前，我们先来了解下Tcp协议和Udp协议TCP（Transmission Control ...
复制链接

扫一扫