Java TCP套接字客户端将输出缓慢写入本地主机

我的设备上有一个应用程序，它正在做截图并将位图保存到内存中。将内存中的最后一个位图流式传输到服务器。 每次我的socket客户端将位图的字节写入服务器时，将原始8MB数据发送到127.0.0.1:9090（在本例中是我的python服务器）大约需要400ms。假设它在本地主机上运行，它不是应该更快吗？我需要每秒向本地主机TCP服务器传输尽可能多的帧。我试着在客户端将位图压缩为PNG，但需要1000毫秒左右，这就是我不想这样做的原因。我需要原始像素，这样JPEG也不会工作，因为它是有损压缩

OutputStream.write（）的执行时间：

设备通过USB连接，WIFI已禁用。我使用以下命令打开了9090端口：

adb reverse tcp:9090 tcp:9090

下面是python服务器：

import socket
import sys
import time
from threading import Thread
from struct import *
from io import BytesIO
from PIL import Image

class BitmapStreamSocket:
    LAST_FRAME = None

    def __init__(self, host, port):
        self.host = host
        self.port = port
        self.last_frame = None
        self.start_server()

    def client_thread(self, sock):
        print("Client thread started")
        while True:
            barr = self.recv_msg(sock)
            if barr:
                stream = BytesIO(bytes(barr))
                print("Just got ", len(barr), "bytes: ", time.time())
            else:
                print("Client just disconnected")
                return

    def send_msg(self, sock, msg):
        # Prefix each message with a 4-byte length (network byte order)
        msg = pack('>I', len(msg)) + msg
        sock.sendall(msg)

    def recv_msg(self, sock):
        # Read message length and unpack it into an integer
        raw_msglen = self.recvall(sock, 4)
        if not raw_msglen:
            return None
        msglen = unpack('>I', raw_msglen)[0]
        # Read the message data
        recvall = self.recvall(sock, msglen)
        return recvall

    def recvall(self, sock, n):
        # Helper function to recv n bytes or return None if EOF is hit
        data = b''
        while len(data) < n:
            packet = sock.recv(n - len(data))
            if not packet:
                return None
            data += packet
        return data

    def start_server(self):
        soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        soc.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,  1)   # SO_REUSEADDR flag tells the kernel to reuse a local socket in TIME_WAIT state, without waiting for its natural timeout to expire
        try:
            soc.bind((self.host, self.port))
        except:
            print("Bind failed. Error : " + str(sys.exc_info()))
            sys.exit()
        soc.listen(5)       # queue up to 5 requests
        print("Socket now listening")

        # infinite loop- do not reset for every requests
        while True:
            connection, address = soc.accept()
            print("Connected with " + str(address[0]) + ":" + str(address[1]))
            t = Thread(target=self.client_thread, args=(connection,))
            t.start()
        soc.close()

导入套接字
导入系统
导入时间
从线程导入线程
从结构导入*
从io导入字节io
从PIL导入图像
类BitmapStreamSocket：
最后一帧=无
定义初始化（自身、主机、端口）：
self.host=host
self.port=端口
self.last_frame=无
self.start_服务器（）
def客户端线程（自线程、sock线程）：
打印（“客户端线程已启动”）
尽管如此：
巴尔=自我记录信息（sock）
如果巴尔：
流=字节（字节（barr））
打印（“刚得到”，len（barr），“字节：”，time.time（）
其他：
打印（“客户端刚刚断开连接”）
返回
def发送消息（自我、sock、消息）：
#以4字节长度（网络字节顺序）作为每条消息的前缀
msg=包装（'>I'，len（msg））+msg
sock.sendall（msg）
def recv_msg（自我，袜子）：
#读取消息长度并将其解压为整数
原始格伦=self.recvall（袜子，4）
如果不是原始格伦：
一无所获
msglen=打开包装（'>I'，原始\msglen）[0]
#读取消息数据
recvall=self.recvall（sock，msglen）
回程回程
def recvall（自身、袜子、n）：
#Helper函数接收n个字节，如果命中EOF，则返回None
数据=b''
而len（数据）

客户端未从服务器接收输入，因为服务器未发送任何输入。客户端只发送数据，服务器接收数据

基本上，我希望在最短的时间内将尽可能多的数据流传输到本地主机服务器，因此我可以获得更多的FPS。对于一个8MB的图像，400ms的速度会很慢

8355000 Bytes / 0.4 seconds = 20887500 Bytes/second

相当于约200 MBit/秒，光纤互联网接入速度很快，USB连接速度惊人

---

这个速度还不错。

谢谢你的回答。你说得对。我不知道这很正常。我必须找到一种在不损失质量的情况下传输像素的快速方法。压缩到PNG在客户端需要1秒的时间…Android设备的图像处理速度通常很慢，尤其是在Java语言中。如果你能在你的应用程序中使用原生C或C++代码来完成这一部分，你会获得一些速度。老实说，即使是4-5 FPS，我也会很满意。如果本机代码是一种方式，那么我将尝试用这种方式进行压缩。这远远不是“那么糟糕”。我们说的是20字节/秒！消费者级网络已经可以实现千兆=125MB/s。通过psping和python服务器进行的快速测试表明，我的机器在localhostrecv（）上的大致理论极限为700 MB/s，大约需要400毫秒—就像客户端write（）一样。我如何知道哪一个正在减慢连接？要尝试的东西可能会改变您的消息长度。尝试使用0长度（因此只有标题）和非常大的长度，看看是否与数据大小有关

import socket
import sys
import time
from threading import Thread
from struct import *
from io import BytesIO
from PIL import Image

class BitmapStreamSocket:
    LAST_FRAME = None

    def __init__(self, host, port):
        self.host = host
        self.port = port
        self.last_frame = None
        self.start_server()

    def client_thread(self, sock):
        print("Client thread started")
        while True:
            barr = self.recv_msg(sock)
            if barr:
                stream = BytesIO(bytes(barr))
                print("Just got ", len(barr), "bytes: ", time.time())
            else:
                print("Client just disconnected")
                return

    def send_msg(self, sock, msg):
        # Prefix each message with a 4-byte length (network byte order)
        msg = pack('>I', len(msg)) + msg
        sock.sendall(msg)

    def recv_msg(self, sock):
        # Read message length and unpack it into an integer
        raw_msglen = self.recvall(sock, 4)
        if not raw_msglen:
            return None
        msglen = unpack('>I', raw_msglen)[0]
        # Read the message data
        recvall = self.recvall(sock, msglen)
        return recvall

    def recvall(self, sock, n):
        # Helper function to recv n bytes or return None if EOF is hit
        data = b''
        while len(data) < n:
            packet = sock.recv(n - len(data))
            if not packet:
                return None
            data += packet
        return data

    def start_server(self):
        soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        soc.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,  1)   # SO_REUSEADDR flag tells the kernel to reuse a local socket in TIME_WAIT state, without waiting for its natural timeout to expire
        try:
            soc.bind((self.host, self.port))
        except:
            print("Bind failed. Error : " + str(sys.exc_info()))
            sys.exit()
        soc.listen(5)       # queue up to 5 requests
        print("Socket now listening")

        # infinite loop- do not reset for every requests
        while True:
            connection, address = soc.accept()
            print("Connected with " + str(address[0]) + ":" + str(address[1]))
            t = Thread(target=self.client_thread, args=(connection,))
            t.start()
        soc.close()

8355000 Bytes / 0.4 seconds = 20887500 Bytes/second