Question

I’ve got a computation (CTR encryption) that requires results in a precise order.

For this I created a multithreaded design that calculates said results, in this case the result is a ByteBuffer. The calculation itself of course runs asynchronous, so the results may become available at any time and in any order. The “user” is a single-threaded application that uses the results by calling a method, after which the ByteBuffers are returned to the pool of resources by said method – the management of resources is already handled (using a thread safe stack).

Now the question: I need something that aggregates the results and makes them available in the right order. If the next result is not available, the method that the user called should block until it is. Does anyone know a good strategy or class in java.util.concurrent that can return asynchronously calculated results in order?

The solution it must be thread safe. I would like to avoid third party libraries, Thread.sleep() / Thread.wait() and theading related keywords other than “synchronized”. Futhermore, The tasks may be given to e.g. an Executor in the correct order if that is required. This is for research, so feel free to use Java 1.6 or even 1.7 constructs.

Note: I’ve tagged these quesions [jre] as I want to keep within the classes defined in the JRE and [encryption] as somebody may already have had to deal with it, but the question itself is purely about java & multi-threading.

Answer 1

Use the executors framework:

ExecutorService executorService = Executors.newFixedThreadPool(5);
List<Future> futures = executorService.invokeAll(listOfCallables);
for (Future future : futures) {
   //do something with future.get();
}
executorService.shutdown();

The listOfCallables will be a List<Callable<ByteBuffer>> that you have constructed to operate on the data. For example:

list.add(new SubTaskCalculator(1, 20));
list.add(new SubTaskCalculator(21, 40));
list.add(new SubTaskCalculator(41, 60));

(arbitrary ranges of numbers, adjust that to your task at hand)

.get() blocks until the result is complete, but at the same time other tasks are also running, so when you reach them, their .get() will be ready.