通过Java有效地通过套接字发送大int []

Question

我正在使用Java应用程序，需要通过套接字连接尽快将500,000个整数的数组从一台Android手机发送到另一台Android手机。无论是使用ObjectOutputStreams，ByteBuffers还是低级的掩码和移位转换，主要的瓶颈似乎都是在转换整数，以便套接字可以使用它们。通过套接字从一个Java应用程序向另一个Java应用程序发送int
[]的最快方法是什么？

这是到目前为止我尝试过的所有代码，其中包括我正在测试的LG Optimus V（600 MHz ARM处理器，Android 2.2）上的基准测试。

低电平遮罩和移位：0.2秒

public static byte[] intToByte(int[] input)
{
    byte[] output = new byte[input.length*4];

    for(int i = 0; i < input.length; i++) {
        output[i*4] = (byte)(input[i] & 0xFF);
        output[i*4 + 1] = (byte)((input[i] & 0xFF00) >>> 8);
        output[i*4 + 2] = (byte)((input[i] & 0xFF0000) >>> 16);
        output[i*4 + 3] = (byte)((input[i] & 0xFF000000) >>> 24);
    }

    return output;
}

使用ByteBuffer和IntBuffer：0.75秒

public static byte[] intToByte(int[] input)
{
    ByteBuffer byteBuffer = ByteBuffer.allocate(input.length * 4);        
    IntBuffer intBuffer = byteBuffer.asIntBuffer();
    intBuffer.put(input);

    byte[] array = byteBuffer.array();

    return array;
}

ObjectOutputStream：3.1秒（我尝试使用DataOutPutStream和writeInt（）而不是writeObject（）对此进行了变体，但是并没有太大的区别）

public static void sendSerialDataTCP(String address, int[] array) throws IOException
{
    Socket senderSocket = new Socket(address, 4446);

    OutputStream os = senderSocket.getOutputStream();
    BufferedOutputStream  bos = new BufferedOutputStream (os);
    ObjectOutputStream oos = new ObjectOutputStream(bos);
    oos.writeObject(array);

    oos.flush();
    bos.flush();
    os.flush();
    oos.close();
    os.close();
    bos.close();

    senderSocket.close();
}

最后，我用来发送byte []的代码比intToByte（）函数还要花费0.2秒的时间

public static void sendDataTCP(String address, byte[] data) throws IOException
{
    Socket senderSocket = new Socket(address, 4446);

    OutputStream os = senderSocket.getOutputStream();
    os.write(data, 0, data.length);
    os.flush();

    senderSocket.close();
}

我正在套接字的两边编写代码，因此我可以尝试各种字节序，压缩，序列化等。必须有一种方法可以在Java中更有效地进行此转换。请帮忙！

Answer 1

正如我在评论中指出的那样，我认为您正在打破处理器的限制。因为这可能对其他人有帮助，所以我将其分解。这是将整数转换为字节的循环：

    for(int i = 0; i < input.length; i++) {
        output[i*4] = (byte)(input[i] & 0xFF);
        output[i*4 + 1] = (byte)((input[i] & 0xFF00) >>> 8);
        output[i*4 + 2] = (byte)((input[i] & 0xFF0000) >>> 16);
        output[i*4 + 3] = (byte)((input[i] & 0xFF000000) >>> 24);
    }

该循环执行500,000次。您的600Mhz处理器每秒可以处理大约600,000,000次操作。因此，循环的每次迭代将为每个操作消耗大约1/1200秒。

同样，使用非常粗糙的数字（我不知道ARM指令集，因此每个动作可能或多或少），这是一个操作计数：

• 测试/分支：5（检索计数器，检索数组长度，比较，分支，增量计数器）
• 掩码和移位：10 x 4（检索计数器，检索输入数组基数，相加，检索掩码，以及移位，乘法计数器，相加偏移量，相加到输出基数，存储）

好的，所以从粗略的角度来看，此循环 最多
需要55/1200秒或0.04秒。但是，您没有处理最佳情况。一方面，对于如此大的阵列，您将不会从处理器缓存中受益，因此，您将在每个阵列存储和加载中引入等待状态。

另外，我描述的基本操作可能会也可能不会直接翻译成机器代码。如果没有（我怀疑没有），那么循环将比我所描述的花费更多。

最后，如果您真的很不幸，JVM尚未对您的代码进行JIT编辑，因此对于循环的某些部分（或全部），它解释字节码而不是执行本机指令。我对Dalvik的了解不足，无法对此发表评论。