java - Java中的UDP线程无限循环

Question

我写了两个程序。现在每个程序都使用线程同时发送和接收数据包。每当我从服务器向客户端发送数据包时，客户端端的消息都会在无限循环中接收。IE; 我添加了一个打印语句来打印发送的消息，这将永远处于无限循环中。我想让它接收消息，然后能够写回服务器并在用户想要的时候退出。

我试过使用 socket.close()，但这使得客户端接收到消息，我只能写回服务器一次。发了之后就不能发了我想做到这一点，以便我可以多次回信。

谁能指出我正确的方向？

我的代码如下；

public class UDPThreadClient extends Thread {

public static int port1;

//Create threaded server
UDPThreadClient (int port1) {
    System.out.println ("Starting threaded client");
    start();
}

public void run() {

    int port = port1;

    try {
        DatagramSocket serverSocket = new DatagramSocket(port1);
           byte[] receiveData = new byte[1024];
           byte[] sendData = new byte[1024];

           while (true) { 
                 DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
                 serverSocket.receive(receivePacket);
                 String sentence = new String( receivePacket.getData());
                 SocketAddress address = receivePacket.getSocketAddress();


                 System.out.println("RECEIVED from " + address + " : " + sentence);

                 InetAddress IPAddress = receivePacket.getAddress();
                 //int port = receivePacket.getPort();
                 String capitalizedSentence = sentence.toUpperCase();
                 sendData = capitalizedSentence.getBytes();
                 DatagramPacket sendPacket =
                 new DatagramPacket(sendData, sendData.length, IPAddress, port);
                 serverSocket.send(sendPacket);
                 //serverSocket.close();
           }  
    } catch (IOException e) {
        System.out.println (e.getMessage());
    }

}

//Create client
public static void main(String[] args) {

    int port = Integer.parseInt(args[0]);
    port1 = Integer.parseInt(args[1]);
    new UDPThreadClient (port1);
    try {

          BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in));

          DatagramSocket clientSocket = new DatagramSocket();
          InetAddress IPAddress = InetAddress.getByName("localhost");

          byte[] sendData = new byte[1024];
          byte[] receiveData = new byte[1024];

          String sentence = inFromUser.readLine();

          sendData = sentence.getBytes();

          DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, IPAddress, port);

          clientSocket.send(sendPacket);

          DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);

          clientSocket.receive(receivePacket);

          String modifiedSentence = new String(receivePacket.getData());

          System.out.println("FROM SERVER:" + modifiedSentence);

         //clientSocket.close();
    } catch (IOException e) {
        System.out.println (e.getMessage());
    }
}
   }

和

public class UDPThreadServer extends Thread {

public static int port1;

//Create threaded client
UDPThreadServer () {

    System.out.println ("Starting threaded server");
    start();


}

public void run() {

    try {
        DatagramSocket clientSocket = new DatagramSocket();

            BufferedReader inFromUser = new BufferedReader (new InputStreamReader(System.in));
            Scanner in = new Scanner (inFromUser);
            InetAddress IPAddress = InetAddress.getByName("localhost");
        byte[] sendData = new byte [1024];
        byte[] receiveData = new byte [1024];

        while (in.hasNextLine()) {
        String sentence = in.nextLine();
        //inFromUser.readLine();
        sendData = sentence.getBytes();

        DatagramPacket sendPacket = new DatagramPacket (sendData, sendData.length, IPAddress, port1);
        clientSocket.send(sendPacket);

        DatagramPacket receivePacket = new DatagramPacket (receiveData, receiveData.length);
        clientSocket.receive (receivePacket);

        String modSentence = new String (receivePacket.getData());
        System.out.println ("FROM SERVER: " + modSentence);
        }
        //clientSocket.close();
    } catch (IOException e) {
        System.out.println (e.getMessage());
    }

}

//Create server
public static void main(String[] args) {

    int port = Integer.parseInt(args[0]);
    port1 = Integer.parseInt(args[1]);
    new UDPThreadServer ();
    try {
        DatagramSocket serverSocket = new DatagramSocket (port);
        byte[] receiveData = new byte[1024];
        byte[] sendData = new byte[1024];

        while (true) {
            DatagramPacket receivePacket = new DatagramPacket (receiveData, receiveData.length);
            serverSocket.receive(receivePacket);
            String sentence = new String(receivePacket.getData());
            SocketAddress address = receivePacket.getSocketAddress();
            System.out.println ("Received from " + address + " : " + sentence);

            InetAddress IPAddress = receivePacket.getAddress();
            String capSentence = sentence.toUpperCase();
            sendData = capSentence.getBytes();
            DatagramPacket sendPacket = new DatagramPacket (sendData, sendData.length, IPAddress, port);
            serverSocket.send(sendPacket);
            //serverSocket.close();
        }

    } catch (IOException e) {
        System.out.println (e.getMessage());
    }
}

}

谢谢。

score 1 · Accepted Answer

查看 UDPClientServer：

当你创建数据报包时，你给它发送它的端口，而不是你发送它的端口。

当我运行你的代码时，什么也没发生。服务器正在等待端口port，而客户端发送到端口port1。如果您改为发送到端口port（无法从 main 方法访问，但将其更改为字段而不是本地方法将解决该问题，则发生无限循环，因为服务器将数据包发送到它正在侦听的同一端口。你的问题。您是否提供与程序的第一个和第二个参数相同的数字？

从服务器，您可以使用receivePacket.getPort()获取数据包来自的端口。

编辑：

你的两个类有很多重复，这可能是混淆的根源。一个类有一个 main，它启动一个客户端，然后创建一个服务器类型的循环测试器。另一个类设置一个服务器，然后创建一个客户端类型测试器。

下面只是您命名为 UDPThreadServer 的类，其中的注释显示了使服务器与 main 方法中的测试代码一起“工作”的更改。请注意，服务器应发送到它未侦听的端口。您还从命令行参数读取端口值。我只是为端口编了一些数字并将它们作为常量插入。

public class UDPThreadServer extends Thread
{

  public static int port1;

  UDPThreadServer()
  {
    //server or client?  it's hard to say.  you call the socket a clientSocket.
    System.out.println("Starting threaded server");
    start();
  }

  public void run()
  {
    try
    {
      // Here client(?) is set up with empty constructor.
      // It is a mystery what port it will get.
      DatagramSocket clientSocket = new DatagramSocket();

      BufferedReader inFromUser =
          new BufferedReader(new InputStreamReader(System.in));
      Scanner in = new Scanner(inFromUser);
      InetAddress IPAddress = InetAddress.getByName("localhost");
      byte[] sendData = new byte[1024];
      byte[] receiveData = new byte[1024];

      while (in.hasNextLine())
      {
        String sentence = in.nextLine();
        // inFromUser.readLine();
        sendData = sentence.getBytes();

        // sending to port1?  that must be the server.
        DatagramPacket sendPacket =
            new DatagramPacket(sendData, sendData.length, IPAddress, port1);
        clientSocket.send(sendPacket);

        DatagramPacket receivePacket =
            new DatagramPacket(receiveData, receiveData.length);
        clientSocket.receive(receivePacket);

        String modSentence = new String(receivePacket.getData());
        System.out.println("FROM SERVER: " + modSentence);
      }
      // clientSocket.close();
    } catch (IOException e)
    {
      System.out.println(e.getMessage());
    }
  }

  // Create server
  public static void main(String[] args)
  {

    // int port = Integer.parseInt(args[0]);
    int port = 1927; // or whatever
    // port1 = Integer.parseInt(args[1]);
    port1 = 1928;
    new UDPThreadServer();
    try
    {
      // server resides on port1?  if client sends to port 1, then this is so.
      DatagramSocket serverSocket = new DatagramSocket(port1);
      byte[] receiveData = new byte[1024];
      byte[] sendData = new byte[1024];

      while (true)
      {
        DatagramPacket receivePacket =
            new DatagramPacket(receiveData, receiveData.length);
        serverSocket.receive(receivePacket);
        String sentence = new String(receivePacket.getData());
        SocketAddress address = receivePacket.getSocketAddress();
        System.out.println("Received from " + address + " : " + sentence);

        InetAddress IPAddress = receivePacket.getAddress();
        String capSentence = sentence.toUpperCase();
        sendData = capSentence.getBytes();

        // where did you get the info from?  Client is set up with an empty constructor, so it is a mystery.
        port = receivePacket.getPort();

        DatagramPacket sendPacket =
            new DatagramPacket(sendData, sendData.length, IPAddress, port);
        serverSocket.send(sendPacket);
        // serverSocket.close();
      }

    } catch (IOException e)
    {
      System.out.println(e.getMessage());
    }
  }
}

score 0 · Accepted Answer

0

不要关闭套接字。

如果这不能回答你的问题，你需要澄清它。

于 2011-05-31T10:06:38.933 回答

score 0 · Accepted Answer

0

while(true)是一个无限循环。在任何情况下你都会放弃它吗？

于 2011-05-31T10:35:36.507 回答

java - Java中的UDP线程无限循环

3 回答 3

Related

Reference