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分析器是最好的起点，但这些可能是CPU消耗的原因。

创建字符串和byte []很昂贵，我会避免这样做。
创建多个数据包而不是批量处理也很昂贵。
可以避免创建新的DatagramPacket。
我会删除邮件之间的重复，因为这会增加您可以避免的冗余工作。
您可以考虑使用二进制格式来避免转换为文本或从文本转换的转换开销。
几乎从来没有一个好时机使用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

编辑：要编写/阅读文本，您可以执行以下操作。

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数据包发送？

1 个答案: