Question

I’m new to socket programming and programming a Java UDP simple client-server application. I’m writing a time/date server client. The client can ask the server for the time and date and it waits for a response. Also, every minute, the server updates all clients with the current time. The client needs to

1. be able to initiate contact with the server and wait for a message back

2. listen for periodic updates from the server

How can I do this using a single DatagramSocket?

I was thinking of creating two threads: one that listens and one that writes. The problem is that in the case that the client initiates contact with the server, it needs to wait to receive an acknowledgement from the server. So, the writing thread also needs to listen for packets from the server sometimes. But in this case, I have two threads listening and the wrong thread will get the acknowledgement.

Is there a way to specify which thread gets the input? Or is there some other way to solve this problem?

I’ve been searching for this answer but unable to find it. The closest I’ve found is Java sockets: can you send from one thread and receive on another?

Answer 1

If there is just one writer thread then it could send the request and go into a wait loop. The listener thread would then get the response, add it to a shared variable (maybe an AtomicReference), and then notify the writer that response has been received.

  // both write and listener threads will need to share this
  private final AtomicReference<Response> responseRef =
     new AtomicReference<Response>();
  ...
  // writer-thread
  writeRequest(request);
  synchronize (responseRef) {
     while (responseRef.get() == null) {
        // maybe put a timeout here
        responseRef.wait();
     }
  }
  processResponse(response);
  ...

  // listener-thread
  Response response = readResponse();
  synchronize (responseRef) {
     responseRef.set(response);
     responseRef.notify();
  }

If you have multiple writers or multiple requests being sent at the same time then it gets more complicated. You’ll need to send some sort of unique id with each request and return it in the response. Then the response thread can match up the request with the response. You’d need a ConcurrentHashMap or other shared collection so that the responder can match up the particular request, add the response, and notify the appropriate waiting thread.