-1

我DataBaseManager在我的 android 应用程序中创建了一个类，用于管理我的应用程序的所有数据库操作。

我有不同的方法来创建、更新和从数据库中检索值。

我在可运行文件上执行此操作并将其提交给线程池执行器。

万一我必须从 this 返回一些值，我该Runnable如何实现它，我知道回调，但是由于方法的数量很大，这对我来说有点麻烦。

任何帮助将不胜感激！

4

2 回答 2

3

您需要使用Callable：Interface Callable<V>

  1. 像Runnable一样，它的实例可能由另一个线程执行。
  2. 但比Runnable更聪明：能够返回结果并检查异常

使用它就像Runnable一样简单：

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

我T用来表示引用类型，例如String.

完成后得到结果：

  • using Future<V>: Future 表示异步计算的结果。提供方法来检查计算是否完成，等待其完成。当计算完成时，使用方法get()检索结果，必要时阻塞，直到它准备好。

      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

    上述方法的缺点是，如果第一个任务计算时间较长，并且所有其他任务都在第一个任务之前结束，则当前线程无法在第一个任务结束之前计算结果。因此，另一种解决方案是使用CompletionService。

  • using CompletionService<V>：一种服务，将新异步任务的生产与已完成任务的结果的消费分离。生产者提交任务以供执行。消费者接受已完成的任务并按照他们完成的顺序处理他们的结果。使用它很简单，如下所示：

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

    然后使用pool.take().get()从可调用实例中读取返回的结果：

     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
  }
于 2013-10-21T12:42:08.747 回答
1

以下是使用可调用的示例代码

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();
        }
    }
于 2013-10-21T12:40:42.993 回答