In the simplest case, you could just go with a Thread + an arbitrary Runnable.
If you want to make the call blocking from the perspective of the caller, you can create a "service" class that runs a worker thread and uses Thread.join(long) to wait for the operation to complete or abandon it after the specified timeout (Pay special attention to the proper handling of InterruptedException so things don't get messed up).
Thread.isAlive() will tell you whether the Thread finished or not.
Retrieving the result is a separate concern; I guess you can deal with that...
[EDIT]
Quick-and-dirty example (do not use in production as is!):
/**
* Actually needs some refactoring
* Also, did not verify for atomicity - should be redesigned
*/
public V theServiceCall(final T param) {
final MyResultBuffer<V> buffer = new MyResultBuffer<V>();
Runnable task = new Runnable() {
public void run() {
V result = ejb.process(param);
buffer.putResult(result);
}
}
Thread t = new Thread(task);
t.setDaemon(true);
t.start();
try {
t.join(TASK_TIMEOUT_MILLIS);
} catch (InterruptedException e) {
// Handle it as needed (current thread is probably asked to terminate)
}
return (t.isAlive()) ? null : buffer.getResult();
}
NOTE: Instead of Thread.setDaemon() you can implement a shutdown flag in your Runnable as it would be a better solution.
[/EDIT]
sleep()ing this can easily be achieved but when it comes, for example, to network IO or database queries it may not be so simple.