服务器未收到客户端的消息

Question

I'm new to Java socket programming and I'm trying to write a program which is supposed to be run on 2 separate controllers. I have written a thread which is used as the communication class.

I have defined a flag called SFlag so that when the value of this flag is changed to 1 anywhere in my program, the corresponding controller will send a hello message to the other controller through sendPackets() function. The other controller will receive this message through ReceivePackets class and it will print the result. Here is the code:

// My UDP communication class
    public class MainConn implements Runnable {

        // Sockets, 1 for sending, and one for receiving
        DatagramSocket socket1, socket2;

        // localIP
        private InetAddress localIP;
        private InetAddress leaderIP;

        // classes to run on separate Threads
        private ReceivePackets rcvThread;


        @Override
        public void run() {
            process();
        }

        public void process() {

            // initialize some parameters
            init1();

            // Make Thread for receiving packets and update counters from all
            // controller
            rcvThread = new ReceivePackets();
            Thread r = new Thread(rcvThread);
            r.start();

            sendPackets();
        }

        public void init1() {
            try {
                // create sockets
                String tempString = config.get("localPort");
                localPort = Integer.parseInt(tempString);
                logger.info("----------here is==========" +localPort);

                leaderIP = InetAddress.getByName("127.0.0.1");
                logger.info("----------here is==========" +leaderIP);

                socket1 = new DatagramSocket(localPort); // for sending
                socket2 = new DatagramSocket(localPort + 1); // for receiving
            } catch (SocketException | UnknownHostException e) {
                e.printStackTrace();
            }
        }


        //*******************************************************

        public void sendPackets() {
            // will be used to begin sending message type II after 3*hello
            // period

            while (true) {
                try {

                    // if network not converged, send message type I, contains:
                    // type number (1) then
                    if (SFlag == 1) {               
                        logger.info("Sending the message");
                        String tempString = new String("Hello");

                        byte[] data = tempString.getBytes();                
                        DatagramPacket sentPacket = new DatagramPacket(data, tempString.length());
                        sentPacket.setAddress(leaderIP);
                        sentPacket.setPort(20222);
                        socket1.send(sentPacket);
                        SFlag = 0;
                    }
                    else {
                        logger.info("Nothinggggggggggggg");
                    }

                    Thread.sleep(5000);// wait for Hello period

                } catch (SocketException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                catch(Exception e){
                    e.printStackTrace();
                }

            }
        }

        class ReceivePackets implements Runnable {

            @Override
            public void run() {
                try {
                    while (true) {
                        logger.info("---------------waiting------------------");
                        byte[] data = new byte[1000];
                        DatagramPacket receivedPacket = new DatagramPacket(data, data.length);
                        socket2.receive(receivedPacket);
                        String senderIP = receivedPacket.getAddress().getHostAddress();
                        String senderPort = "" + receivedPacket.getPort();
                        String message = new String(data, 0, receivedPacket.getLength());
                        logger.info(message);

                        System.out.println("Received Message: "+message);
                        }

                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            }
        }
    }

When the value of SFlag is changed to 1, it seems that the first controller is sending the message ("Sending the message" is printed), but there seems to be a problem with receiving the message on the second controller, because the received message is not printed.

What is the problem?

Answer 1

There are some issues with your code:

(1) Since both threads rely on SFlag for communication, make sure it is declared with the volatile keyword:

private volatile int SFlag = 0;

The volatile keyword prevents the variable from being cached, so both threads will see the same value all the time. Besides that, reading and writing operations on volatile variables are atomic.

(2) You have a hardcoded port number in this line:

sentPacket.setPort(20222);

Make sure this is the port number used by the ReceivePackets thread. Ideally we should never have magic numbers mixed with the code. So you should move that port number to a separate variable or constant.

(3) In Java you shouldn't create a String with new . For example, this is bad practice:

String tempString = new String("Hello"); // bad practice

You should do:

String tempString = "Hello";

My last piece of advice is: clean up your code . You can look at Oracle's tutorial on sending and receiving datagram packets here: https://docs.oracle.com/javase/tutorial/networking/datagrams/clientServer.html