在线程池执行器中从Runnables返回值的最简单，最有效的方法是什么？

Question

I have created a DataBaseManager Class in my android app that manages all database operations for my app.

I have different methods to create,update, and retrieve value from database.

I do it on a runnable and submit it to the Thread pool Executor.

In case, I have to return some value from this Runnable , how can I achieve it, I know about callbacks but it will be little cumbersome for me as the number of methods large.

Any help will be appreciated!

Answer 1

You need to use Callable : Interface Callable<V>

1. Like Runnable , It's instances are potentially executed by another thread.
2. But smarter then Runnable : Capable of returning result and checked Exception

Using it is as much simple as Runnable :

private final class MyTask extends Callable<T>{
  public T call(){
     T t;
    // your code
       return t;
    }
}

I am using T to represent a reference type eg String .

Getting the result upon completion:

• using Future<V> : A Future represents the result of an asynchronous computation. Methods are provided to check if the computation is complete, to wait for its completion. The result is retrieved using method get() when the computation has completed, blocking if necessary until it is ready.

    List<Future<T>> futures = new ArrayList<>(10); for(int i = 0; i < 10; i++){ futures.add(pool.submit(new MyTask())); } T result; for(Future<T> f: futures) result = f.get(); // get the result 

  The disadvantages of above approach is that, if first task takes a long time to compute and all the other tasks ends before the first, the current thread cannot compute the result before the first task ends. Hence another solution would be to use CompletionService .

• using CompletionService<V> : A service that decouples the production of new asynchronous tasks from the consumption of the results of completed tasks. Producers submit tasks for execution. Consumers take completed tasks and process their results in the order they complete. Using it is as simple as follows:

   CompletionService<T> pool = new ExecutorCompletionService<T>(threadPool); 

  And then use pool.take().get() to read the returned result from callable instances:

    for(int i = 0; i < 10; i++){ pool.submit(new MyTask()); } for(int i = 0; i < 10; i++){ T result = pool.take().get(); //your another code } 

Answer 2

the below is the sample code for using callable

import java.util.concurrent.Callable;
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;

    public class Test {
        public static void main(String[] args) throws Exception {
            ExecutorService executorService1 = Executors.newFixedThreadPool(4);     

            Future f1 =executorService1.submit(new callable());
            Future f2 =executorService1.submit(new callable());     
            System.out.println("f1 " + f1.get());
            System.out.println("f1 " + f2.get());

            executorService1.shutdown();
        }

    }


    class callable implements Callable<String> {
        public String call() {
             System.out.println(" Starting callable Asynchronous task" + Thread.currentThread().getName());
             try {
                Thread.currentThread().sleep(1000);
            } catch (InterruptedException e) {          
                e.printStackTrace();
            }
            System.out.println(" Ending callable Asynchronous task" +  Thread.currentThread().getName());
            return Thread.currentThread().getName();
        }
    }