Salve. Sto creando una chat client-server che per ora funziona solo in locale. Il problema è che all'atto della connessione del client al server, il client non riceve messaggi dal server. Il server sembra rilevare correttamente la connessione del client. Il codice non è breve, provo a mettere le parti più rilevanti (che comunque potrebbero essere utili a qualcuno).

Server
codice:
public class Server implements Runnable {


    private List<ServerClient> clients = new ArrayList<ServerClient>();
    
    private DatagramSocket socket;
    private int port;
    private boolean running = false;
    private Thread run, manage, send, receive;
    
    public Server(int port) {
        this.port = port;
        try {
            socket = new DatagramSocket(port);
        } catch (SocketException e) {
            e.printStackTrace();
            return;
        }
        run = new Thread(this, "Server");
        run.start();
    }
    
    public void run() {
        running = true;
        System.out.println("Server started on port " + port);
        manageClients();
        receive();
    }
    
    private void manageClients() {
        manage = new Thread("Manage") {
            public void run() {
                while(running) {
                    //niente per adesso
                }
            }
        };
        manage.start();
    }
    
    private void receive() {
        receive = new Thread("Receive") {
            public void run() {
                while(running) {
                    byte[] data = new byte[1024];
                    DatagramPacket packet = new DatagramPacket(data, data.length);
                    try {
                        socket.receive(packet);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    System.out.println("Ricevuto pacchetto da: " + packet.getAddress().toString() + " , " + packet.getPort());
                    process(packet);
                }
            }
        };
        receive.start();
    }
    
    private void process(DatagramPacket packet) {
        String string = new String(packet.getData());
        if(string.startsWith("/c/")) {
            //UUID id = UUID.randomUUID();
            int id = UniqueIdentifier.getIdentifier();
            clients.add(new ServerClient(string.substring(3, string.length()), packet.getAddress(), 
                    packet.getPort(), UniqueIdentifier.getIdentifier()));
            System.out.println(string.substring(3, string.length()));
            String ID = "/c/" + id;
            send(ID, packet.getAddress(), packet.getPort());
        } else if(string.startsWith("/m/")){
            sendToAll(string);
        } else if(string.startsWith("/d/")) {
            String id = string.split("/d/|/e/")[1];
            disconnect(Integer.parseInt(id), true);
        }        
        else {
            System.out.println(string);
        }
    }
    
    private void disconnect(int id, boolean status) {
        ServerClient c = null;
        for(int i = 0; i < clients.size(); i++) {
            if(clients.get(i).getID() == id) {
                c = clients.get(i);
                clients.remove(i);
                break;
            }
        }
        String message = "";
        if(status) {
            message = "Client " + c.getName() + " (" + c.getID() + ") @" 
                    +c.getAddress().toString() + ":" + c.getPort() + " disconnected";
        } else {
            message = "Client " + c.getName() + " (" + c.getID() + ") @" 
                    +c.getAddress().toString() + ":" + c.getPort() + " timed out";
        }
        System.out.println(message);
    }
    
    private void sendToAll(String message) {
        for(int i = 0; i < clients.size(); i++) {
            ServerClient client = clients.get(i);
            send(message.getBytes(), client.getAddress(), client.getPort());
        }
    }
    
    private void send(String message, InetAddress address, int port) {
        message += "/e/"; //carattere di terminazione
        send(message.getBytes(),address,port);
    }
    
    private void send(final byte[] data, final InetAddress address, final int port) {
        send = new Thread("Send") {
            public void run() {
                DatagramPacket packet = new DatagramPacket(data, data.length, address, port);
                System.out.println("Server is sending a packet to: " + 
                        packet.getAddress() + " , " + packet.getPort());
                try {
                    socket.send(packet);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        };
        send.start();
    }
}
ClientWindow
codice:
public class ClientWindow extends JFrame implements Runnable {
    
    private static final long serialVersionUID = 1L;
    
    private JPanel contentPane;
    private JTextField txtMessage;
    private JTextArea history;
    
    private Client client;
    private Thread listen, run;
    private boolean running = false;
    
    public ClientWindow(String name, String address, int port) {
        setTitle("Client");
        client = new Client(name, address, port);
        boolean connect = client.openConnection(address);
        if(!connect) {
            System.err.println("Connection Failed");
            console("Connection Failed");
        }
        createUI();
        console("Attempting a connection to " + address + ":" + port + ", user: " + name);
        String connection = "/c/" + name;
        client.send(connection.getBytes());
        running = true;
        run = new Thread("Running Thread");
        run.start();
    }


    private void createUI() {
        //ho tolto per abbreviare
    }
    
    private void console(String message) {
        history.append(message + "\n\r");
        history.setCaretPosition(history.getDocument().getLength());
    }
    
    public void run() {
        System.out.println("Client run() method");
        listen();
    }
    
    private void send(String message, boolean text) {
        if(message.equals("")) return;
        if(text) {
            message = client.getName() + ": " + message;
            message = "/m/" + message;
        }
        client.send(message.getBytes());
        txtMessage.setText("");
    }
    
    private void listen() {
        System.out.println("Client listen() method");
        listen = new Thread("Listen") {
            public void run() {
                while(running) {
                    String message = client.receive();
                    if(message.startsWith("/c/")) {
                        client.setID(Integer.parseInt(message.split("/c/|/e/")[1]));
                        console("Successfully connected to server. ID: " + client.getID()); 
                    } else if(message.startsWith("/m/")) {
                        String text = message.split("/m/|/e/")[1];
                        console(text);
                    }
                }
            }
        };
        listen.start();
    }
}

Client

codice:
public class Client {    
    
    private String name, address;
    private int port;    
    private DatagramSocket socket; //Protocollo UDP
    private InetAddress ip;
    
    private Thread send;
    
    private int ID = -1;
    
    public Client(String name, String address, int port) {
        this.name = name;
        this.address = address;
        this.port = port;
    }
    
    public String getName() {
        return name;
    }
    
    public String getAddress() {
        return address;
    }
    
    public int getPort() {
        return port;
    }


    public boolean openConnection(String address) {
        try {
            socket = new DatagramSocket();
            ip = InetAddress.getByName(address);
        } catch (UnknownHostException e) {
            e.printStackTrace();
            return false;
        } catch (SocketException e) {
            e.printStackTrace();
            return false;
        }
        System.out.println("Client connection ok");
        return true;
    }
    
    public String receive() {
        byte[] data = new byte[1024]; //buffer dove riceviamo i dati
        DatagramPacket packet = new DatagramPacket(data, data.length); //pacchetti UDP
        System.out.println("Client is receiveing a packet from: " + packet.getAddress() + " , " + packet.getPort());
        try {
            socket.receive(packet); //riceviamo i pacchetti dal network
        } catch (IOException e) {
            e.printStackTrace();
        }
        String message = new String(packet.getData());
        return message;
    }
    
    public void send(final byte[] data) {
        send = new Thread("Send") {
            public void run() {
                DatagramPacket packet = new DatagramPacket(data, data.length, ip, port);
                System.out.println("Client is sending a packet to: " + packet.getAddress() + " , " + packet.getPort());
                try {
                    socket.send(packet);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        };
        send.start();
    }
    
    public void close() {
        new Thread() {
            public void run() {
                synchronized(socket) {
                    socket.close();
                }
            }
        }.start();
    }


    public void setID(int ID) {
        this.ID = ID;
    }
    
    public int getID() {
        return ID;
    }
}
In particolare la receive() della classe Client e la listen() della classe ClientWindow sembrano non funzionare.