Question

有没有办法在Java ThreadPoolExecutor中确定执行任务的优先级？我面临的问题是，当基于相同的指定执行标识符时，需要按顺序执行线程。

它们都被提交给相同的ThreadPoolExecutor但由于处理延迟，任务A2可能在任务A1（具有相同的执行标识符）之前完成。它们应遵循与进入时相同的顺序，同时不阻止执行其他任务（具有不同的执行标识符）（例如B1，B2，C1等）。

是否存在处理类似问题的常见模式？例如，任务A1，B1，B2，A2，C1进入池进行处理。它们应按以下方式处理：

A1

B1

B2（如果B1已完成，否则等到B1完成，而A2或C1轮流）

A2（如果A1已完成，否则等待A1完成，而B2，如果尚未启动，或C1轮流）

C1

Answer 1

create a ThreadPoolExecutor可以a PriorityBlockingQueue。

Answer 2

使用java.util.concurrent包而不是线程池。它有Future任务可以帮助您订购和排队可操作的项目。

http://docs.oracle.com/javase/6/docs/api/java/util/concurrent/package-summary.html

更新1：

您可以使用以下示例。如果我错了，请纠正我，我在Java FutureTasks中看到的一件事就是链接。在.NET中，您可以链接多个任务并在单个任务的调用方法体外定义依赖项（例如ContinueWith和TaskContinuationOptions，Wait（task）等...）。

package sample;
import java.util.concurrent.*;

public class FutureTaskTest {

    public static void main(String[] args)
    {

         ExecutorService executor = Executors.newFixedThreadPool(3);

         final FutureTask<String> a1 = new FutureTask<String>(
                    new Callable<String>()
                    {
                        public String call()
                        {
                           System.out.println("a1 finished.");
                           return "Success";

                        }
                    });

         FutureTask<String> a2 = new FutureTask<String>(
                    new Callable<String>()
                    {
                        public String call()
                        {
                           try {
                            a1.get();
                        } catch (InterruptedException | ExecutionException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }//wait for a1 to finish.
                           System.out.println("a2 finished.");
                           return "Success";
                        }
                    });
         final FutureTask<String> b1 = new FutureTask<String>(
                    new Callable<String>()
                    {
                        public String call()
                        {
                            System.out.println("b1 finished.");
                            return "Success";
                        }
                    });
         FutureTask<String> b2 = new FutureTask<String>(
                    new Callable<String>()
                    {
                        public String call()
                        {
                            try {
                                b1.get();
                            } catch (InterruptedException | ExecutionException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                            }//wait for b1 to finish.
                           System.out.println("b2 finished.");
                            return "Success";
                        }
                    });
         FutureTask<String> c1 = new FutureTask<String>(
                    new Callable<String>()
                    {
                        public String call()
                        {
                            System.out.println("c1 finished.");
                            return "Success";
                        }
                    });


         executor.execute(a1);
         executor.execute(a2);
         executor.execute(b1);
         executor.execute(b2);
         executor.execute(c1);
         }

}

这是输出。

a1 finished.
b1 finished.
b2 finished.
c1 finished.
a2 finished.

问候Kajal

确定要在Java ThreadPoolExecutor中执行的任务的优先级

2 个答案: