正文 

当前位置： 首页 > java > java教程

socket之粘包发生问题

Dear坏小子 Dear坏小子     2022-09-16     388

关键词：

粘包

注意注意注意：

res=subprocess.Popen(cmd.decode('utf-8'),
shell=True,
stderr=subprocess.PIPE,
stdout=subprocess.PIPE)

的结果的编码是以当前所在的系统为准的，如果是windows，那么res.stdout.read()读出的就是GBK编码的，在接收端需要用GBK解码

且只能从管道里读一次结果

注意：命令ls -l ; lllllll ; pwd 的结果是既有正确stdout结果，又有错误stderr结果

from socket import *
import subprocess

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

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

while True:
    conn,addr=tcp_socket_server.accept()
    print('客户端',addr)

    while True:
        cmd=conn.recv(BUFSIZE)
        if len(cmd) == 0:break

        res=subprocess.Popen(cmd.decode('utf-8'),shell=True,
                         stdout=subprocess.PIPE,
                         stdin=subprocess.PIPE,
                         stderr=subprocess.PIPE)

        stderr=act_res.stderr.read()
        stdout=act_res.stdout.read()
        conn.send(stderr)
        conn.send(stdout)
服务端
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)

while True:
    msg=input('>>: ').strip()
    if len(msg) == 0:continue
    if msg == 'quit':break

    s.send(msg.encode('utf-8'))
    act_res=s.recv(BUFSIZE)

    print(act_res.decode('utf-8'),end='')
客户端

再基于udp制作一个远程执行命令的程序

from socket import *
import subprocess

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

udp_server=socket(AF_INET,SOCK_DGRAM)
udp_server.bind(ip_port)

while True:
    #收消息
    cmd,addr=udp_server.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_server.sendto(stderr,addr)
    udp_server.sendto(stdout,addr)
udp_server.close()
服务端
from socket import *
ip_port=('127.0.0.1',9003)
bufsize=1024

udp_client=socket(AF_INET,SOCK_DGRAM)


while True:
    msg=input('>>: ').strip()
    udp_client.sendto(msg.encode('utf-8'),ip_port)

    data,addr=udp_client.recvfrom(bufsize)
    print(data.decode('utf-8'),end='')
客户端

TCP有粘包，UDP没有粘包

 

粘包问题就是接收方不知道消息之间的界限，不知道一次性提取多少数据而造成的

  1. TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。
  2. UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。
  3. tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），那也不是空消息，udp协议会帮你封装上消息头。

两种情况下会发生粘包。

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

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()
服务端
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('feng'.encode('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()
服务端
客户端
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 feng'.encode('utf-8'))

拆包的发生情况

当发送端缓冲区的长度大于网卡的MTU时，tcp会将这次发送的数据拆成几个数据包发送出去。

补充问题一：为何tcp是可靠传输，udp是不可靠传输

基于tcp的数据传输请参考我的另一篇文章http://www.cnblogs.com/linhaifeng/articles/5937962.html，tcp在数据传输时，发送端先把数据发送到自己的缓存中，然后协议控制将缓存中的数据发往对端，对端返回一个ack=1，发送端则清理缓存中的数据，对端返回ack=0，则重新发送数据，所以tcp是可靠的

而udp发送数据，对端是不会返回确认信息的，因此不可靠

补充问题二：send(字节流)和recv(1024)及sendall

recv里指定的1024意思是从缓存里一次拿出1024个字节的数据

send的字节流是先放入己端缓存，然后由协议控制将缓存内容发往对端，如果待发送的字节流大小大于缓存剩余空间，那么数据丢失，用sendall就会循环调用send，数据不会丢失

 

网络编程之粘包(代码片段)

...　　　　　　2.数据量发送大，接受少首先需要掌握一个socket收发消息的原理应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容 查看详情

网络编程基础之粘包现象(代码片段)

...py　1#！/usr/bin/envpython32#-*-coding:utf-8-*-3#writebycongcong456importsocket78server=socket.socket(family=socket.AF_INET,type=socket.SOC 查看详情

socket网络编程之粘包问题详解(代码片段)

...态和用户态之前交换数据势必会导致发送效率降低，因此socket为提高传输效率，发送方往往要收集到足够多的数据后才发送一次数据给对方。若连续几次需要send的数据都很少，通常TCPsocket会根据优化算法把这些数据合成一个TCP... 查看详情

网络编程之粘包问题使用socketserver实现并发(代码片段)

一、粘包问题注意：粘包问题只有tcp协议并且udp协议永远不会粘包粘包问题的产生：简述：粘包问题的产生主要是由于tcp协议传输数据（其内置的nagle算法来进行的）会将数据较小的且发送时间较短的合并成一个包从发送端发送... 查看详情

netty之粘包拆包bytetomessagedecoder(代码片段)

目录拆包粘包处理的方式netty的处理方式netty实现编码解码1、cumulator.cumulate()拼接数据包2、callDecode()解析数据包总结LengthFieldBasedFrameDecoder拆包粘包粘包产生的原因：两个包小于缓存区的大小，传送数据会将两个包都放在... 查看详情

netty之粘包拆包bytetomessagedecoder(代码片段)

目录拆包粘包处理的方式netty的处理方式netty实现编码解码1、cumulator.cumulate()拼接数据包2、callDecode()解析数据包总结LengthFieldBasedFrameDecoder拆包粘包粘包产生的原因：两个包小于缓存区的大小，传送数据会将两个包都放在... 查看详情

netty之粘包拆包bytetomessagedecoder(代码片段)

目录拆包粘包处理的方式netty的处理方式netty实现编码解码1、cumulator.cumulate()拼接数据包2、callDecode()解析数据包总结LengthFieldBasedFrameDecoder拆包粘包粘包产生的原因：两个包小于缓存区的大小，传送数据会将两个包都放在... 查看详情

网络编程之粘包(代码片段)

粘包：传输层协议有tcp和udp两种tcp：TransmissionControlProtocol传输控制协议，基于数据流，收发的消息不能为空，需要在客户端和服务端都添加空消息的处理机制tcp是可靠性协议，数据的收发都需要确认信息，这就降低了传输效率，... 查看详情

什么是粘包？socket中造成粘包的原因是什么？哪些情况会发生粘包现象？

只有TCP有粘包现象，UDP永远不会粘包！粘包：在接收数据时,一次性多接收了其它请求发送来的数据（即多包接收）。如，对方第一次发送hello，第二次发送world，　　在接收时，应该收两次，一次是hello，一次是world，但事实上是... 查看详情

查漏补缺：socket编程：tcp粘包问题和常用解决方案（上）

　　1、TCP粘包问题的产生（发送端）　　由于TCP协议是基于字节流并且无边界的传输协议，因此很容易产生粘包问题。TCP的粘包可能发生在发送端，也可能发生在接收端。发送端的粘包是TCP协议本身引起的，TCP为了提高传输效... 查看详情

socket编程(代码片段)

TCP下粘包问题两种情况下会发生粘包。1、发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据了很小，会合到一起，产生粘包）发送方：AB　　#其实放在缓存里没发送发送方：B　　#其实放在缓存里没发... 查看详情

网络编程-之------粘包现象

...2.客户端没有粘，可能是在服务端粘了首先需要掌握一个socket收发消息的原理应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出... 查看详情

socket的粘包问题解决方案

粘包：由于接受recv有最大限制，管道中有大于最大限制字节时， 第二次recv的会是之前残留的信息，这种现象叫做粘包。TCP协议是面向连接的，面向流的，当在发送数据时接受方不知道要收多少字节的数据，但由于缓存区大... 查看详情

scoket模块粘包问题tcp协议特点(代码片段)

scoket（）模块函数用法importsocketsocket.socket(socket_family,socket_type,protocal=0)获取tcp/ip套接字tcpsock=socket.socket(socket.AF_INET,socket.SOCK_STREAM)获取udp/ip套接字udpsock=socket.socket(socket.AF_INET,socket.S 查看详情

粘包和拆包(代码片段)

写在前面粘包、拆包是Socket编程中最常遇见的一个问题，本文只对粘包、拆包现象及发生的原因做简要分析，具体如何解决粘包和拆包的问题，在后续文章中会详细介绍。什么是粘包、拆包TCP是个"流"协议，所谓流，就是没有界... 查看详情

socket传输简单的信息以及粘包问题的解决(代码片段)

　　一、简单的socket程序——传输简短文字：#-*-coding:utf-8-*-#-*-Author:WangHW-*-importsocketwhw_client=socket.socket(socket.AF_INET,socket.SOCK_STREAM)whw_client.connect((‘127.0.0.1‘,9001))while1:cmd=input(‘>>&g 查看详情

socket粘包(代码片段)

产生粘包：1.发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据了很小，会合到一起，产生粘包）2.接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，... 查看详情

socket解决半包粘包问题(代码片段)

 最近项目遇到socket服务端接收报文不全的问题，与其客户端约定的是报文长度+报文体。然而当客户端数据量大的时候，用分包发送，导致服务端报文日志接收不完整，于是想着先读出包体长度，再读出包体，不够就一直读... 查看详情