阻塞线程，直到它从其他线程（java）获得特定信号为止

Question

I have an java server application communicating with clients via sockets. Every client request is handled in a new thread. But for some requests I need to synchronize two clients.

Example:

• Client A sends a request to the Server S.
• Thread S1 on S accepts the request of A.
• S1 informs Client B about this request (via GoogleCloudMessaging).
• S1 SHOULD BLOCK NOW
• Client B receives the information from S and sends a request to S.
• Thread S2 on S accepts the request of B.
• S1 SHOULD BE RELEASED NOW and get the message from S2
• S1 sends the answer to Client A

I know about the Lock Condition mechanism, but this does not work here, because I don't know the condition when creating the threads. I need something like:

// Pseudo Code
// on the S1 Thread, first argument beeing a signal ID, second a timeout
s1.waitForSignal("clientB", 10000);
// and on the S2 Thread to continue S1
SignalSender.send("clientB");

Is anything like this possible in Java? Is there any other solution for my problem?

Answer 1

Your problem seems to be that you do not have a shared reference on which you could invoke wait / notify (not to mention a shared lock condition that you could use).

Well, first of all there is stuff shared between those two threads already: namely, in your case, the string "ClientB" . If you have this, all you need to do is map that string to a single reference in a place that is accessible by both classes.

The simplest implementation would be to hold a static map field somewhere and just fill it with monitor objects somehow:

public final class Monitors {

    private Monitors() {}

    private static final Map<String, Object> monitors = new HashMap<String, Object>();

    static { monitors.put("ClientB", new Object()); }

    public static Object get(String key) { return monitors.get(key); }

}

Of course, you may want to write a proper service that manages this mapping and perhaps uses locks and conditions internally. Also, a good idea would be to encapsulate the waiting and signaling functionality within the service itself and then use it like: monitorService.waitForSignalsFrom("ClientB") .