ExecutorCompletionService不适用于给定参数

Question

In my application, ExecutorCompletionService is used to run couple of tasks which implement Callable. When the tasks are submitted to ExecutorCompletionServer, it gives compile error saying

The method submit(Callable<T>) in the type ExecutorCompletionService<T> is not applicable for the arguments (AbstractTask<capture#2-of ? extends Object>)  

This is how I submit tasks`.

List<AbstractTask<? extends Object>> taskList =new ArrayList<>();
        addTasks(new TaskA()); //TaskA,TaskB,TaskC are child classses of AbstractTask. addTasks() method add the child classes to taskList.
        addTasks(new TaskB());
        addTasks(new TaskC());
        List<Future<? extends Object>> futureList= new ArrayList<Future <? extends Object> >();

        final ExecutorService pool = Executors.newFixedThreadPool( TASK_SIZE );

        final ExecutorCompletionService<T> completionService = new ExecutorCompletionService<T >(pool);

        for ( AbstractTask<? extends Object>  callable : taskList) {
                futureList.add( completionService.submit(callable) );
        }  

This is addTaskMethod.

public void addTasks(AbstractTask<? extends Object> task){
            taskList.add(task);
        }

This is my AbstractClass.

public abstract class AbstractTask<T extends Object> implements
        java.util.concurrent.Callable<T> {

    @Override
    public T call() throws Exception {

        return begin();
    }
    public abstract <B extends Object> B begin() throws RuntimeException ;

}

Even the following method 'submit()' in java.util.concurrent.ExecutorCompletionService<V> accept arguement as

public Future<V> submit(Callable<V> task) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<V> f = newTaskFor(task);
    executor.execute(new QueueingFuture(f));
    return f;
}   

Why I can't submit my AbstractTask<? extends Object> AbstractTask<? extends Object> ? My AbstractTask can have any value which extends from Object. (If I simple remove the <? extends Object> in for loop, then it fines.But again My tool:Eclipse warns Type safety: The expression of type AbstractTask needs unchecked conversion to conform to Callable<T> . How can I sortout this ? )

EDIT: This is TaskA class.

public class TaskA  extends AbstractTask<Object> {

    @SuppressWarnings("unchecked")
    @Override
    public java.lang.String begin() throws RuntimeException {
        System.out.println("Task A runs");
        return "A";
    }

}

Answer 1

You're creating an ExecutorCompletionService<T> . This is thus an ExecutorCompletionService that accepts instances of Callable<T> .

But you're submitting instances of AbstractTask<? extends Object> AbstractTask<? extends Object> . A Callable<? extends Object> Callable<? extends Object> is not a Callable<T> .

A Callable<T> returns instances of T. A Callable<? extends Object> Callable<? extends Object> returns some unknown type, for which all we know is that the type extends Object. So that's basically like wanting to put unknown objects into a paper shredder . The paper shredder is only able to shred paper, not any kind of object. The compiler prevents you from doing that, because it obviously won't work fine.

You need an ExecutorCompletionService<Object> .

Answer 2

In the following line we are creating an instance of ExecutorCompletionService<T>

final ExecutorCompletionService<T> completionService = new ExecutorCompletionService<T >(pool);

It will only accept Callable<T> and submit will return Future<T> and when task is over each Future<T> will return result (using get ) of type T .

If we check the signature of submit method in ExecutorCompletionService :

public Future<V> submit(Callable<V> task)

Then it specifies the type variable V such that all the callables should be of same type V . IMO, Executor Completion Service will not allow a task of type Callable<? extends Object> Callable<? extends Object> to be submitted because it is like saying that my task extends Object which means it can take almost every thing. So we cannot use unbound wildcard with ECS and had to restrict the possible result.

On a side note I believe Callable<? extends Object> Callable<? extends Object> and Callable<?> are same.