Interrupting a Thread in a Remote Object?

Question

HI,
I am trying to get some thread synchronization to happen between a client and a remote RMI object. Essentially what I am trying to accomplish, is that if I interrupt a call on a blocking method in the remote object, I want the thread to throw the InterruptException. For example, the following code represents what I am trying to accomplish:
package bca.test.rmi;
import java.rmi.Naming;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
public class InterruptThreadApp {
RemoteBlockingObjectInt remote = null;
public static void main(String[] args) throws Exception {
//Create the remote object
RemoteBlockingObject obj = new RemoteBlockingObject();
//bind it to the registry
Naming.rebind("rmi://localhost/blocking", obj);
//start the client, or the thread which will access the blocking call remotely
InterruptThreadApp app = new InterruptThreadApp();
Thread blocking = null;
//wait for the thread to start
synchronized ( app ) {
blocking = app.startClient();
app.wait();
Thread.sleep(2000);
//now interrupt the thread (note: the remote object should be blocking in
//the blockingMethod().. this should produce an InterruptException?
blocking.interrupt();
public Thread startClient() {
Thread t = new Thread("Client") {
public void run() {
try {
//get a handle to the stub
remote = (RemoteBlockingObjectInt) Naming.lookup("rmi://localhost/blocking");
//now make a call to the blocking method, but first wake up the client
synchronized ( InterruptThreadApp.this ) {
InterruptThreadApp.this.notify();
//now make the blocking call
remote.blockingMethod();
catch (InterruptedException e) {
System.out.println("WooHoo! This is what we want! But it never gets thrown :(");
catch (Exception e) {
e.printStackTrace();
t.start();
return t;
package bca.test.rmi;
import java.rmi.server.UnicastRemoteObject;
import java.rmi.RemoteException;
import java.rmi.Remote;
public class RemoteBlockingObject extends UnicastRemoteObject implements RemoteBlockingObjectInt {
Object obj = new Object();
public RemoteBlockingObject() throws RemoteException {
super();
public void blockingMethod() throws RemoteException, InterruptedException {
synchronized (obj) {
System.out.println("About to block.. so we can be interrupted later");
obj.wait();
interface RemoteBlockingObjectInt extends Remote {
public void blockingMethod() throws RemoteException, InterruptedException;
When I make a call to "remote.blockingMethod()", it blocks in the remote object (buy just "wait" ing). I want to interrupt this thread, by issuing an Thread.interrupt(). When I do so (I call "blocking.interrupt()"), nothing happens... no exception is thrown.. it just silently fails.
Ok, so I suppose that we can not interrupt a remote thread.. that is fine. But what if I want to interrupt the RMI thread making the remote call? I don't want it to block forever. How can I "cancel" the remote call?
Ideally, I would like the remote.blockingMethod() call to throw an InterruptException when I issue an "interrupt()" on the blocking thread. Any suggestions on how I might accomplish this?
Thanks,
Bryan

Answer 1

While you can interrupt the RMI call, you cannot stop the active processing. That is, you cannot force a thread to stop (see the Java API documentation on Thread.stop().)
Since the Client RMI call is a waiting thread, you need another Client thread to do a secondary RMI call. The trick is to have the new RMI endpoint connection thread on the RMI Server interrupt the original RMI endpoint connection thread.
The only way you can interrupt an RMI call is to have the endpoint connection thread that runs on the RMI Server be aware that the user may wish to interrupt it.
The best means of interruption is for the endpoint connection thread to use "worker threads". The endpoint connection thread waits for the workers to finish and is interruptible by both the workers and other endpoint connection threads.
Another means of interruption is for the endpoint connection thread to segment the task into units of work and check for an interruption between those units of work.
There are two ways I've done RMI call interruption.
One is for the Client to pass a unique id (UID -- that uniquely identifies the request) to the Server with the original call. When the Client wishes to interrupt the original call, using the separate thread, it does a new RMI call to the Server passing the UID.
The new endpoint connection thread, using the UID, interrupts the original endpoint connection thread.
The major problem with this is the unique id. It absolutely, positively must be unique. Otherwise you run the risk of Client_A purging Client_B's request.
The second method requires callback. If your Client is behind a firewall then RMI callback is near impossible. In such a case you must come up with a way for the Server to call the Client that is secure (the firewall problem.)
The Client must export a remote object and pass that remote object to the Server with the original call.
The endpoint connection thread recognizes the remote object and does a call back to the Client passing information that uniquely identifies itself (UID). Since the Server generates the UID, it can guarantee uniqueness.
The Client callback implementation runs as a separate thread since the Client is in fact an RMI Server itself (when it did the export.) The Client must save the UID. The Client must start a new thread for the interrupt procedure or inform a waiting thread that the Server called back.
Just like method one, above, when the Client wishes to interrupt the original call, using the separate thread, it does a new RMI call to the Server passing the UID.
The new endpoint connection thread, using the UID, interrupts the original endpoint connection thread. Simple.
For an academic example using call back go over to Jini.org. They have an example called "Cancellation" at:
http://starterkit-examples.jini.org/
For a professional, open source implementation of both these methods go over to CoopSoft.com. The Tymeac (Java) projects support canceling both waiting and autonomous requests at:
http://www.coopsoft.com/JavaProduct.html