Python TCP套接字无法在突发中发送消息

嗨，我有多个系统使用TCP连接通过消息进行通信

我的send函数如下所示

def _send(self, message, dest):

    self.sendLock.acquire()
    message = pickle.dumps(message)
    #sending length
    message_length = len(message)
    self.outChan[dest].send('<MESSAGELENGTH>%s</MESSAGELENGTH>'
                            % str(message_length))

    for message_i in range(0, message_length, 1024):
        self.outChan[dest].send(message[:1024])
        message = message[1024:]

    self.sendLock.release()

def\u发送（自身、消息、目的地）：
self.sendLock.acquire（）
message=pickle.dumps（消息）
#发送长度
消息长度=len（消息）
self.outChan[dest]。发送（“%s”
%str（信息长度））
对于范围（0，消息长度，1024）内的消息\u i：
self.outChan[dest].send（消息[：1024]）
message=消息[1024:]
self.sendLock.release（）

接收线程如下所示：

def readlines(self, sock):

    while True:

        msg = ''

        opTag = '<MESSAGELENGTH>'
        clTag = '</MESSAGELENGTH>'

        while not all(tag in msg for tag in (opTag, clTag)):
            msg = sock.recv(1024)

        msglen = int(msg.split(clTag)[0].split(opTag)[1])
        msg = msg.split(clTag)[1]

        while len(msg) < msglen:
            msg += sock.recv(msglen-len(msg))

        self.rec.put(pickle.loads(msg))

def读写线（self，sock）：
尽管如此：
味精=“”
opTag=''
clTag=''
虽然不是全部（标记在msg中表示标记在（opTag，clTag）中）：
msg=sock.recv（1024）
msglen=int（msg.split（clTag）[0]。split（opTag）[1]）
msg=msg.split（clTag）[1]
而len（msg）

从self.rec读取消息后，将向发件人发送确认消息

我已经实现了自己的缓冲区来控制网络中的流量。在任何时候，我都会发送atmost MAX_BUFFER_大小的消息，但没有收到任何确认

问题是：当程序启动时，它发送最大缓冲区大小的消息而不等待确认。但只接收到其中几个最大缓冲区大小的消息

在其中一个最大缓冲区大小为5的模拟中，总共发送了100条消息，没有收到m2、m3和m4。所有其他消息均已接收（按发送顺序）

---

我怀疑错误在初始发送突发中，但我无法找出确切的问题。

接收线程中有一些错误：

在检查接收到的消息的开始和结束标记时，您并没有附加到已接收的部分，而是覆盖它

检测到消息长度后，您将丢失后续消息，这些消息的结束标记已被接收，但尚未分析

您可能正在将多条消息放在

self.rec

中

这是一份更正后的表格，附有解释更改的注释：

def readlines(self, sock):

    msg = '' # initialize outside since otherwise remiander of previous message would be lost

    opTag = '<MESSAGELENGTH>' # no need to repeat this in each iteration
    clTag = '</MESSAGELENGTH>' # no need to repeat this in each iteration

    while True:

        while not all(tag in msg for tag in (opTag, clTag)):
            msg += sock.recv(1024) # += rather than =

        msglen = int(msg.split(clTag)[0].split(opTag)[1])
        msg = msg.split(clTag, 1)[1] # split just once, starting from the left

        while len(msg) < msglen:
            msg += sock.recv(msglen-len(msg))

        self.rec.put(pickle.loads(msg[:maglen])) # handle just one message
        msg = msg[msglen:] # prepare for handling future messages

def读写线（self，sock）：
msg=''#在外部初始化，否则前一条消息的remander将丢失
opTag=''#无需在每次迭代中重复此操作
clTag=''#无需在每次迭代中重复此操作
尽管如此：
虽然不是全部（标记在msg中表示标记在（opTag，clTag）中）：
msg+=sock.recv（1024）#+=而不是=
msglen=int（msg.split（clTag）[0]。split（opTag）[1]）
msg=msg.split（clTag，1）[1]#只拆分一次，从左侧开始
而len（msg）