CPU-Wise，如何优化UDP包发送？

Question

我目前有一款游戏，我已经为其实现了客户端和服务器。

然后我让服务器向客户端发送有关其位置的数据，客户端向服务器发送运动输入等。

问题是 CPU 飙升至 100%。我已经将高使用率直接连接到以下代码，该代码位于每秒调用十次的 update() 方法中：

try{
        sendToClientUDP(("ID:" + String.valueOf(uid)));
        sendToClientUDP(("Scale:" + GameServer.scale));

        for (Clients cl : GameServer.players){
            //sendToClient(("newShip;ID:" + cl.uid).getBytes(), packet.getAddress(), packet.getPort());
            sendToClientUDP((("UID:" + cl.uid +";x:" + cl.x)));
            sendToClientUDP((("UID:" + cl.uid +";y:" + cl.y)));
            sendToClientUDP((("UID:" + cl.uid +";z:" + cl.z)));
            sendToClientUDP((("UID:" + cl.uid +";Rotation:" + (cl.rotation))));
            cl.sendToClientUDP(new String("newShip;ID:" + uid));
            sendToClientUDP(new String("newShip;ID:" + cl.uid));
        }
        }catch (Exception e){
            e.printStackTrace();
        }

删除代码，高 CPU 使用率消失。

这是我的 sendToClientUDP() 方法。

public void sendToClientUDP(String str){
        if (!NPC){ //NPC is checking if it is a computer-controlled player.
        UDP.sendData(str.getBytes(), ip, port);
        }
    }

这是我的 UDP.sendData() 方法：

public static void sendData(String data, InetAddress ip, int port) {
    sendData(data.getBytes(), ip, port);
}

public static void sendData(byte[] data, InetAddress ip, int port) {
    DatagramPacket packet = new DatagramPacket(data, data.length, ip, port);
    try {
        socket.send(packet);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

为什么仅仅通过发送UDP数据包就使用了这么多CPU？如果有的话，我可以做些什么来减少它？

Answer 1

我建议您删除或优化产生如此多的代码 CPU，CPU 分析器是最好的起点，但这些可能是 [=56= 的原因]消费。

创建字符串和 byte[] 很昂贵，我会避免这样做。
创建多个数据包而不是对它们进行批处理也很昂贵。
可以避免创建新的 DatagramPacket。
我会删除消息之间的重复，因为这会增加您可以避免的冗余工作。
您可以考虑使用二进制格式来避免转换 to/from 文本的翻译开销。
几乎没有使用的好时机new String()它几乎肯定是多余的。

编辑：这就是我的想法。不是每个客户端发送 5 个数据包，而是总共只发送一个数据包。对于十个客户端，您发送 1/50 的数据包，从而减少开销。

import java.io.IOException;
import java.net.*;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.ArrayList;
import java.util.List;

/**
 * Created by peter on 31/07/15.
 */
public class PacketSender {
    public static void main(String[] args) throws IOException {
        PacketSender ps = new PacketSender(InetAddress.getByName("localhost"), 12345);
        List<Client> clients = new ArrayList<>();
        for(int i=0;i<10;i++)
            clients.add(new Client());

        for(int t = 0; t< 3;t++) {
            long start = System.nanoTime();
            int tests = 100000;
            for (int i = 0; i < tests; i++) {
                ps.sendData(1234, 1, clients);
            }
            long time = System.nanoTime() - start;
            System.out.printf("Sent %,d messages per second%n", (long) (tests * 1e9 / time));
        }
    }


    final ThreadLocal<ByteBuffer> bufferTL = ThreadLocal.withInitial(() -> ByteBuffer.allocate(8192).order(ByteOrder.nativeOrder()));
    final ThreadLocal<DatagramSocket> socketTL;
    final ThreadLocal<DatagramPacket> packetTL;

    public PacketSender(InetAddress address, int port) {
        socketTL = ThreadLocal.withInitial(() -> {
            try {
                return new DatagramSocket(port, address);
            } catch (SocketException e) {
                throw new AssertionError(e);
            }
        });
        packetTL = ThreadLocal.withInitial(() -> new DatagramPacket(bufferTL.get().array(), 0, address, port));
    }

    public void sendData(int uid, int scale, List<Client> clients) throws IOException {
        ByteBuffer b = bufferTL.get();
        b.clear();
        b.putInt(uid);
        b.putInt(scale);
        b.putInt(clients.size());
        for (Client cl : clients) {
            b.putInt(cl.x);
            b.putInt(cl.y);
            b.putInt(cl.z);
            b.putInt(cl.rotation);
            b.putInt(cl.uid);
        }
        DatagramPacket dp = packetTL.get();
        dp.setData(b.array(), 0, b.position());
        socketTL.get().send(dp);
    }

    static class Client {
        int x,y,z,rotation,uid;
    }
}

运行此性能测试时会打印

Sent 410,118 messages per second
Sent 458,126 messages per second
Sent 459,499 messages per second

编辑：对于 write/read 文本，您可以执行以下操作。

import java.nio.ByteBuffer;

/**
 * Created by peter on 09/08/2015.
 */
public enum ByteBuffers {
    ;
    /**
     * Writes in ISO-8859-1 encoding. This assumes string up to 127 bytes long.
     *
     * @param bb to write to
     * @param cs to write from
     */
    public static void writeText(ByteBuffer bb, CharSequence cs) {
        // change to stop bit encoding to have lengths > 127
        assert cs.length() < 128;
        bb.put((byte) cs.length());
        for (int i = 0, len = cs.length(); i < len; i++)
            bb.put((byte) cs.charAt(i));
    }

    public static StringBuilder readText(ByteBuffer bb, StringBuilder sb) {
        int len = bb.get();
        assert len >= 0;
        sb.setLength(0);
        for (int i = 0; i < len; i++)
            sb.append((char) (bb.get() & 0xFF));
        return sb;
    }

    private static final ThreadLocal<StringBuilder> SB = new ThreadLocal<>() {
        @Override
        protected Object initialValue() {
            return new StringBuilder();
        }
    };

    public static String readText(ByteBuffer bb) {
        // TODO use a string pool to reduce String garbage.
        return readText(bb, SB.get()).toString();
    }
}

如果你需要更复杂的东西，你应该考虑使用我写的Chronicle-Bytes。它有

支持 64 位内存大小，包括内存映射 64 位。
堆外线程安全操作。
字符串的 UTF-8 编码。
压缩类型，如停止位编码。
自动字符串池以减少垃圾。
通过引用计数确定性地清理堆外资源。

CPU-Wise，如何优化UDP包发送？

CPU-Wise, How can I optimize UDP packet sending?

java

sockets

udp