java - 是否可以让多个线程监听同一个 DatagramSocket？

Question

我正在用 Java 编写一个聊天程序，我已经被这个问题困了几个小时。这是我的类，等待客户端连接到服务器。每次新客户端连接时，我都会创建一个新的 ChatClient(String name, DatagramSocket serverSocket,InetAddress IPAddress, int port) 对象。

我的想法是每个 ChatClient 对象都在套接字上监听，当从与 ChatClient 相同的 IP 发送包时，它会处理它，否则什么也不做。

就像现在一样，当我只连接一个客户端时；客户端获取每 2 个包，然后 WaitForConnection() 中的 run() 获取其余包。

所以我的问题是，是否可以让多个线程无损失地监听同一个 DatagramSocket(每个人都能收到所有发送的信息)。如果有解决方案，如何解决？

private ArrayList<ChatClient> clients;
    private DatagramSocket serverSocket;
    private boolean running;

    public WaitForConnection() {
        running = true;
        clients = new ArrayList<ChatClient>();

        try {
            serverSocket = new DatagramSocket(ChatServer.port);
        } catch (SocketException e) {
            System.out
                    .println("Couldn't open socket. Port might alreadybe in use");
            e.printStackTrace();
        }
        try {
            serverSocket.setReuseAddress(true);
        } catch (SocketException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    @Override
    public void run() {

        while (running) {
            for (ChatClient ch : clients) {
                System.out.println(ch.toString());
            }

            byte[] handShake = new byte[1024];
            DatagramPacket receivePacket = new DatagramPacket(handShake,
                    handShake.length);

            try {
                serverSocket.receive(receivePacket);
            } catch (IOException e) {
                System.out.println("Waiting for connections error");
                e.printStackTrace();
            }
            String connect = new String(receivePacket.getData());
            System.out.println(connect);

            InetAddress IPAddress = receivePacket.getAddress();

            // if connect == "OPEN_CONNECTION" -> new client want to connect.
            if (connect.contains("openconnection")) {

                int port = receivePacket.getPort();

                try {

                    ChatClient chatClient = new ChatClient(
                            IPAddress.getHostName(), serverSocket, IPAddress,
                            port);

                    // Don't want double clients.
                    for (int i = 0; i < clients.size(); i++) {
                        if (clients.get(i).equals(chatClient)) {
                            clients.remove(i);
                        }
                    }
                    clients.add(chatClient);

                } catch (IOException e) {
                    System.out.println("Couldn't connect to client");
                    e.printStackTrace();
                }
            }
        }
    }
}

如果需要查看 ChatClient 的代码。

public class ChatClient extends Thread {
    private InetAddress IPAddress;
    private DatagramSocket serverSocket;
    private int port;
    private String name;

    public ChatClient(String name, DatagramSocket serverSocket,
            InetAddress IPAddress, int port) throws IOException {
        super(name);
        this.name = name;
        this.IPAddress = IPAddress;
        this.serverSocket = serverSocket;
        this.port = port;

        byte[] confirmConnection = new byte[1024];
        String connected = "Connection to server established";
        confirmConnection = connected.getBytes();

        serverSocket.send(new DatagramPacket(confirmConnection,
                confirmConnection.length, IPAddress, port));
        start();

    }

    public void run() {
        while (true) {
            byte[] message = new byte[1024];
            DatagramPacket receivedPacket = new DatagramPacket(message,
                    message.length);
            try {
                serverSocket.receive(receivedPacket);
            } catch (IOException e) {
                System.out
                        .println("Something went wrong receiving data in ChatClient");
            }
            if (receivedPacket.getAddress().equals(IPAddress)) {
                String connect = new String(receivedPacket.getData());
                connect = connect.toUpperCase();
                System.out.println(connect + "client side");
                message = connect.getBytes();
                try {
                    serverSocket.send(new DatagramPacket(message,
                            message.length, IPAddress, port));
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}

Answer 1

多个线程可以从同一个 DatagramSocket 接收数据，但只有其中一个线程会获取每个数据报。

我不明白你为什么认为你需要这个。