System to handle the short lived async task
I would strongly recommend a use of Java 8 features to make your library (which has an API) an easier to use system.

Your Task interface should be a @FunctionalInterface. It is one already, but you should make it formal with the annotation:

@FunctionalInterface
interface Task&lt;V&gt;{
    public  V doTask();
}


Now, any time you want a task, you can do things like:

Task&lt;Long&gt; wordcount = () -&gt; countWords("Hello World");


The above is equivalent to:

Task&lt;Long&gt; wordcount = new Task&lt;Long&gt;() {
    @Override
    public Long doTask() {
        return countWords("Hello World");
    }
}


This leads on to the next concern I have with the TaskManager. Here's your code copied:


class AsyncTaskManager
{
    private ExecutorService service;

    public AsyncTaskManager(ExecutorService service){
        this.service = service;
    }


    public &lt;T&gt; Future&lt;T&gt;  submit(Callable&lt;T&gt; callable){
        Future&lt;T&gt; result = service.submit(callable);
        return result;
    }

    public void shutdown(){
        service.shutdown();
        try {
            service.awaitTermination(60, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            service.shutdownNow();
        }
        service.shutdownNow();
    }

}



The following concern me:


The service should be final, make it immutable.
The service is created outside the class, but then shut down inside the class. This is asymmetrical. If the service is created outside then it should be shut-down outside.
The class should be AutoClosable instead of having the shutdown() method.


Again, I would use a Java-8 concept called a supplier. Instead of passing in a service, pass in a method that can create a service. That way, you can still add a custom service, but you create it, not the people who call you.

About the try/catch block in the shutdown... you should use a finally block instead of what you currently have, and also, you should reset the interrupted flag if there is an interrupt. This is better than doing nothing (which is what you currently do). It avoids the exception, but makes the next thing that checks have to handle it. In other words, you pass the buck.

This is how it would look:

class AsyncTaskManager implements AutoClosable {
    private final ExecutorService service;

    public AsyncTaskManager(Supplier&lt;ExecutorService&gt; service){
        this.service = service.get();
    }

    public &lt;T&gt; Future&lt;T&gt;  submit(Callable&lt;T&gt; callable){
        return service.submit(callable);
    }

    @Override        
    public void close() {

        service.shutdown();

        try {
            service.awaitTermination(60, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            service.shutdownNow();
        }
    }

}