非阻塞Java方法

Question

Suppose I want to make a method non-blocking, and make the app continue as it is and still surely get the return value:

Key key = datastore.put(complexInstance);
String name = key.getName();
doSomethingWithTheName(name);

Or simply, for some Java environment that can't run thread for more than 30 seconds.

Where in the put method:

public Key put(Object instance){
  Key result = null;
  // In here process could take up time, say 30 seconds or more, IDK :-/
  return result; 
}

What is the strategy to achieve this?

Answer 1

You could use an implementation of an ExecutorService in combination with a Future object ( http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Future.html ). You would simply start a new thread (or use an existing one) and could fetch the result later.

Answer 2

Java 8 made the process a lot simpler:

//field in a manager class
ScheduledExecutorService es = Executors.newScheduledThreadPool(10);

//Schedule a task
es.schedule(() -> { /* contents of a runnable */ }, 0, TimeUnit.SECONDS);

Otherwise, you can still just use an anonymous runnable with the Scheduler:

es.schedule(new Runnable() {

    public void run() {
        /* do what you need */
    }

}, 0, TimeUnit.SECONDS);

However, as you specified, you will still need to do something for a returned value. There isn't really much that you can do, aside from use something from either a state manager, or to execute relevant methods within your runnable.

Answer 3

Your class needs to take a thread pool, probably via the interface ExecutorService , that the methods will run on. You could make it a private static variable, but more likely it's better for it to be passed in or at least configured by the client code, who will set size, etc.

Note that if IO is the asynchronous part, it's better to use something built on Java's nio framework than to use lots of threads.

You will need to return a Future of some sort. Through Java 7 at least (I'm not sure about 8), Java's future library is very weak and omits some obviously needed functionality. Look at either Functional Java or Google's library. But you will notice that many libraries (Apache's MINA, Amazon Web Service's Java SDK, etc.) implement their own promise libraries to get over these weaknesses. (I did the same in my company's code base. Whoops.)