标签: futuretask

我刚刚开始研究Java中的Futures和ScheduledExecutorService,我想知道为什么我的Callable没有按照我指示的时间表运行.在此示例代码中,可调用运行一次,但应用程序永远不会完成,任务也不会再次运行,这是我预期会发生的事情(我确定问题与我的期望有关).

Runnables运作良好; Callables似乎永远阻止,但我不确定为什么......我错过了什么？

谢谢!

   public class ExecutorExample {

    /**
     * @param args
     * @throws ExecutionException 
     * @throws InterruptedException 
     */
    public static void main(String[] args) throws InterruptedException, ExecutionException {

        ScheduledExecutorService scheduler =  Executors.newScheduledThreadPool(5);

        FutureTask<ArrayList<String>> ft1 = new FutureTask<ArrayList<String>>(new Callable<ArrayList<String>>(){
            @Override
            public ArrayList<String> call() {
                ArrayList<String> stuff = new ArrayList<String>();
                for(int i = 0;i<10;i++){
                    String thing ="Adding " + i + " to result"; 
                    stuff.add(thing);
                    System.out.println(thing);

                }
                return stuff;
            }});

        scheduler.scheduleAtFixedRate(ft1, 0, 1, TimeUnit.SECONDS);

        System.out.println(ft1.get());
        System.out.println(ft1.isDone());

    }
}

我有3个FutureTask<T>物体.我希望它们是异步处理的.但是,只要其中一个FutureTasks get()方法没有返回,null我想继续,即我的方法(包装器)返回,并且不等到处理其他两个FutureTasks.我想到了类似的东西:

private File wrapper(final File file) {
    ExecutorService executors = Executors.newCachedThreadPool();
    File returnFile;
    FutureTask<File> normal= ...
    FutureTask<File> medium=...     
    FutureTask<File> huge=...

    executors.execute(normal);
    executors.execute(medium);
    executors.execute(huge);
    try {
        if((returnFile=normal.get()) != null || 
           (returnFile=medium.get()) != null ||  
           (returnFile=huge.get()) != null)

            return returnFile;

    } catch(ExecutionException | InterruptedException e) { }
}

我不确定如何以正确的方式捕获异常(由get()抛出),因为我假设它们将被抛出,因为我只是返回而不等待其他两个任务完成.此外,我怀疑代码是否会像预期的那样工作.我觉得我接近解决方案但却遗漏了一些东西.

我有一个singleThreadExecutor,以执行我按顺序提交给它的任务,即一个接一个的任务,没有并行执行.

我有runnable,这是这样的

MyRunnable implements Runnable {

@Override
public void run() {
    try {
        Thread.sleep(30000);
    } catch (InterruptedException e1) {
        e1.printStackTrace();
    }

}

例如,当我向上述单线程执行程序提交三个MyRunnable实例时,我希望第一个任务执行,因为Thread.sleep在TIMED_WAITING中有执行线程(我可能错误的具体州).其他两个任务不应该分配线程来执行它们,至少在第一个任务完成之前.

所以我的问题是如何通过FutureTask API获取此状态或以某种方式到达执行任务的线程(如果没有这样的线程然后任务等待执行或挂起)并获得其状态或者可能由某些其他方式？

FutureTask只定义了isCanceled()和isDone()方法,但这些方法还不足以描述Task的所有可能的执行状态.

我检查了Oracle Java API,它给出了FutureTask.isDone()的一些信息.

但我需要检查任务是否已完成或因任何错误而终止.isDone()方法即使完成/终止也会返回.但我需要知道它是否由于某些问题而完成或终止.

我正在ThreadPoolExecutor中运行多个任务。我将其初始化如下：

private VideoExportExecutor executor;
private BlockingQueue<Runnable> jobQueue;

public void initialiseVideoProcessor()
{
    jobQueue = new LinkedBlockingQueue<Runnable>();
    executor = new VideoExportExecutor(1, 1, Long.MAX_VALUE, TimeUnit.SECONDS, jobQueue);
}

我已经实现了runnable（VideoExportThread）的实现，其中包含一种getProgress()跟踪提交任务进度的方法。我提交如下实例：

executor.submit(new VideoExportThread(gcmPath));

我正在查询一种查询executor / blockingQueue的当前/待处理线程的方法。我试图使用jobQueue.toArray()和重写exe​​cutor方法，beforeExecute(Thread t, Runnable r)但是在两种情况下，返回的runnable都是FutureTask类型，它不包含太多数据。我是否可以使用它来检索我的原始VideoExportThread实例，以识别正在运行的实例并查询其进度？

谢谢

我想取消提交给ExecutorService的任务,从而允许相应的线程从队列中选择一个新任务.

现在这个问题已在这个论坛上多次回答....比如检查Thread.currentThread().interrupt()或catch (InterruptedException e).但是,如果控制流跨越多种方法,那么进行这些检查会使代码变得笨拙.因此,如果可能的话,请在java中提出一些优雅的方法来实现此功能.

我面临的问题是future.cancel实际上不会取消任务.相反,它只是发送一个InterruptedException执行任务,任务的责任是标记自己完成并释放线程.

所以我所做的是,每当在执行中的任何地方抛出异常时,我必须放下下面的代码块,这显然看起来不太好!

if(e instanceof InterruptedException) {
                    throw e;
                }

那么,如何在以下代码片段中实现此功能:

public class MonitoringInParallelExp {

        public static void main(String[] args) throws InterruptedException {
            MyClass1 myClass1 = new MyClass1();
            ExecutorService service = Executors.newFixedThreadPool(1);
            Future<String> future1 = service.submit(myClass1);
            Thread.sleep(2000);
            System.out.println("calling cancel in Main");
            future1.cancel(true);
            System.out.println("finally called cancel in Main");
            service.shutdown();
        }
    }

    class MyClass1 implements Callable<String> {
        @Override
        public String call() throws Exception {
            try{
                MyClass2 myClass2 = new MyClass2();
                myClass2.method2();
            } catch …

关闭执行程序时应该在哪里捕获RejectedExecutionExceptions？我试过了：

 future {
        Option(reader.readLine)
      } onComplete {
        case Success(v) =>
        case Failure(e) => e match {
          case ree: RejectedExecutionException =>
          // doesn't work
      }

和：

 try {
        future {
          Option(reader.readLine)
        } onComplete {
          ...
        }
      } catch {
        case ree: RejectedExecutionException =>
          // doesn't work
      }

也行不通。仍然得到：

Exception in thread "pool-99-thread-1" java.util.concurrent.RejectedExecutionException
at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:1768)
at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:767)
at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:658)
at scala.concurrent.impl.ExecutionContextImpl.execute(ExecutionContextImpl.scala:105)
at scala.concurrent.impl.CallbackRunnable.executeWithValue(Promise.scala:37)
at scala.concurrent.impl.Promise$DefaultPromise.tryComplete(Promise.scala:133)
at scala.concurrent.Promise$class.complete(Promise.scala:55)
at scala.concurrent.impl.Promise$DefaultPromise.complete(Promise.scala:58)
at scala.concurrent.impl.Future$PromiseCompletingRunnable.run(Future.scala:23)
at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:886)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:908)
at java.lang.Thread.run(Thread.java:662)

这里是 Flutter 初学者，所以如果我的问题很愚蠢，请不要介意......

如何将 Stream 转换为 Future？

我有一个 Stream，它只是多次调用请求的 URL，因为它是一个 Stream。我希望能够获取数据而不是加载状态...因为我总是永远加载

某处是否有类似Future.fromStream()功能的东西而我错过了？

我能实现这个目标吗？

我没有提供任何代码，因为我认为如果您需要代码，就不需要它，我可以编辑问题

我有一份Future任务 清单

   futureList.add(executor.submit(new Callable(someList)));

当那些被执行时,我想从中得到结果物品.但是如何在没有循环的情况下完成它并检查futuretask是否完成,然后获得结果呢？

for (int i = 0; i < futureList.size(); i++) {
                    if (futureList.get(i).isDone()) {
    .....
}}

我考虑过制作一些额外的通知等待结构,但我仍然必须知道哪个线程完成了所以它不能帮助我避免一直循环.有什么建议？

我正在尝试以下操作并认为我会失败

val failure = Future { Failure(new Exception) }

但我得到了

Future(Success(Failure(java.lang.Exception)))

谁能回答为什么？