Re: RMI and CyclicBarrier and crashes
Kenneth P. Turvey wrote:
I have a program I've been developing and I've run into a small problem
I'm not sure how to resolve. The basic idea is that I have a server that
exports a single object using RMI. Clients make calls on this and cycle
through some work that needs to be done. On occasion a client program or
even a client machine may crash and I would like to be able to recover
from this. I've written the code to do so and now the clients can
restart where they left off with one exception.
There is a point where the server uses a CyclicBarrier to sync all the
clients and make sure that they are ready to start the next task in the
loop. If one of the clients crashes while in CyclicBarrier.await() and
then reconnects and hits the CyclicBarrier.await() again, it counts as
two threads towards the thread count in the CyclicBarrier.
Now this isn't what I want. When the client dies, I'd like all the
threads it has running to also go away, or at least not count toward the
total in the CyclicBarrier somehow.
This actually brings up another problem I have with my code now that may
need to be fixed in order to handle this problem. Right now the server
doesn't know anything about the client disconnecting. I'm not sure how
to make the Server aware of the disconnect. Is there a simple way to do
so? Is there something I can do when the client disconnects abruptly to
get rid of the thread in the CyclicBarrier?
Thanks. If you can help with this you are Java god.
The first thing I have to say is that there is something wrong with your
architecture but I cannot tell what since I don't know what you want to
achieve. That being said here is a very simple solution to your particular
problem.
The server's RMI runtime has no way of telling if two concurrent calls have
to be treated as one - they could be just two concurrent calls originating
from the same client. You need to handle it by yourself.
The simplest thing would be to add an argument to your RMI method that would
serve as a "call id". Something along the lines of (forgive me the typos):
ConcurrentMap<String, Thread> callThreadMap;
CyclicBarrier barrier;
void function(String callId) {
try {
final Thread prevThread =
callThreadMap.replace(callId, Thread.currentThread());
if (prevThread != null) {
//will cause InterruptedException in the interrupted thread
//and BrokenBarierException in other threads waiting on
//a barier
prevThread.interrupt();
}
while (true) {
try {
//do work
//somehow we have to
//handle the case that the work has already been
//completed for a particular client
//before the thread was interrupted
//or - better yet - resume work that was started
//by interrupted thread
barier.await();
//clean interrupted status of this thread
//in case it was interrupted after returning
//from barier.await()
Thread.interrupted();
return;
}
catch (InterruptedException e) {
//just return from the method
//since it means the call is no longer relevant to the client
//possibly it would be better to throw an exception
return;
}
catch (BrokenBarierException e) {
//ignore and try to wait again
//we have to reset the barrier only once
//so we synchronize on it to choose one
//thread that will reset it
synchronized (barrier) {
if (barrier.isBroken() {
barrier.reset();
}
}
}
}
}
finally {
callThreadMap.remove(callId);
}
}
--
Michal