Java执行者：如何设置任务优先级？

https://stackoverflow.com/questions/3198660

02-10-2019
|

题

是否有可能优先考虑执行者执行的任务？我在JCIP中发现了一些有关这是可能的陈述，但是我找不到任何例子，也找不到文档中的任何相关内容。

来自JCIP：

执行策略指定任务执行的“什么，何时，何时，何时和如何”，包括：

...

应执行任务的顺序应以什么顺序（FIFO，LIFO， 优先顺序)?

...

UPD: ：我意识到我没有问我要问什么。我真正想要的是：

如何使用/模拟设置线程优先级（即什么是 thread.setPriority()）有执行者框架吗？

解决方案

目前是唯一的具体实施执行人界面是 ThreadPoolExecutor 和计划的ThreadPoolExecutor

而不是使用公用事业 /工厂类执行者, ，您应该使用构造函数创建一个实例。

你可以通过阻塞到ThreadPoolExecutor的构造函数。

封锁的实现之一，优先型布洛克格式让您将比较器传递给构造函数，这样，您可以决定执行顺序。

其他提示

这里的想法是在执行人中使用PriorityBlockingqueue。为了这：

创建一个比较我们未来的比较器。
为未来创建一个优先级的代理。
覆盖“ newtaskfor”，以便在我们的代理中包装每个将来。

首先，您需要优先考虑未来：

    class PriorityFuture<T> implements RunnableFuture<T> {

    private RunnableFuture<T> src;
    private int priority;

    public PriorityFuture(RunnableFuture<T> other, int priority) {
        this.src = other;
        this.priority = priority;
    }

    public int getPriority() {
        return priority;
    }

    public boolean cancel(boolean mayInterruptIfRunning) {
        return src.cancel(mayInterruptIfRunning);
    }

    public boolean isCancelled() {
        return src.isCancelled();
    }

    public boolean isDone() {
        return src.isDone();
    }

    public T get() throws InterruptedException, ExecutionException {
        return src.get();
    }

    public T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
        return src.get();
    }

    public void run() {
        src.run();
    }
}

接下来，您需要定义可以正确排序优先期货的比较器：

class PriorityFutureComparator implements Comparator<Runnable> {
    public int compare(Runnable o1, Runnable o2) {
        if (o1 == null && o2 == null)
            return 0;
        else if (o1 == null)
            return -1;
        else if (o2 == null)
            return 1;
        else {
            int p1 = ((PriorityFuture<?>) o1).getPriority();
            int p2 = ((PriorityFuture<?>) o2).getPriority();

            return p1 > p2 ? 1 : (p1 == p2 ? 0 : -1);
        }
    }
}

接下来，让我们假设我们有这样的工作很长：

class LenthyJob implements Callable<Long> {
    private int priority;

    public LenthyJob(int priority) {
        this.priority = priority;
    }

    public Long call() throws Exception {
        System.out.println("Executing: " + priority);
        long num = 1000000;
        for (int i = 0; i < 1000000; i++) {
            num *= Math.random() * 1000;
            num /= Math.random() * 1000;
            if (num == 0)
                num = 1000000;
        }
        return num;
    }

    public int getPriority() {
        return priority;
    }
}

然后，为了优先执行这些作业，代码看起来像：

public class TestPQ {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        int nThreads = 2;
        int qInitialSize = 10;

        ExecutorService exec = new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,
                new PriorityBlockingQueue<Runnable>(qInitialSize, new PriorityFutureComparator())) {

            protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
                RunnableFuture<T> newTaskFor = super.newTaskFor(callable);
                return new PriorityFuture<T>(newTaskFor, ((LenthyJob) callable).getPriority());
            }
        };

        for (int i = 0; i < 20; i++) {
            int priority = (int) (Math.random() * 100);
            System.out.println("Scheduling: " + priority);
            LenthyJob job = new LenthyJob(priority);
            exec.submit(job);
        }
    }
}

这是很多代码，但这几乎是可以完成的唯一方法。

在我的机器上，输出如下：

Scheduling: 39
Scheduling: 90
Scheduling: 88
Executing: 39
Scheduling: 75
Executing: 90
Scheduling: 15
Scheduling: 2
Scheduling: 5
Scheduling: 24
Scheduling: 82
Scheduling: 81
Scheduling: 3
Scheduling: 23
Scheduling: 7
Scheduling: 40
Scheduling: 77
Scheduling: 49
Scheduling: 34
Scheduling: 22
Scheduling: 97
Scheduling: 33
Executing: 2
Executing: 3
Executing: 5
Executing: 7
Executing: 15
Executing: 22
Executing: 23
Executing: 24
Executing: 33
Executing: 34
Executing: 40
Executing: 49
Executing: 75
Executing: 77
Executing: 81
Executing: 82
Executing: 88
Executing: 97

您可以实现自己的threadFactory并将其设置在ThreadPoolExecutor中：

ThreadPoolExecutor threadPool = new ThreadPoolExecutor(1, numOfWorkerThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
threadPool.setThreadFactory(new OpJobThreadFactory(Thread.NORM_PRIORITY-2));

我的opjobthreadFactory看起来如下：

public final static class OpJobThreadFactory implements ThreadFactory {
   private int priority;
   private boolean daemon;
   private final String namePrefix;
   private static final AtomicInteger poolNumber = new AtomicInteger(1);
   private final AtomicInteger threadNumber = new AtomicInteger(1);

   public OpJobThreadFactory(int priority) {
      this(priority, true);
   }

   public OpJobThreadFactory(int priority, boolean daemon) {
      this.priority = priority;
      this.daemon = daemon;
      namePrefix = "jobpool-" +poolNumber.getAndIncrement() + "-thread-";
   }

   @Override
   public Thread newThread(Runnable r) {
      Thread t = new Thread(r, namePrefix + threadNumber.getAndIncrement());
      t.setDaemon(daemon);
      t.setPriority(priority);
      return t;
   }
}

您可以使用优先级阻塞队列的ThreadPoolExecutor如何使用ThreadPooleExecutor和自定义任务实现PriorityBlockingqueue

您可以指定一个 ThreadFactory 在里面 ThreadPoolExecutor 构造函数（或 Executors 工厂方法）。这使您可以为执行人提供给定线程优先级的线程。

要获得不同作业的不同线程优先级，您需要将其发送给具有不同线程工厂的执行者。

请注意，SetPriority（..）通常确实如此不是在Linux下工作。有关完整详细信息，请参见以下链接：

只想增加我对此讨论的贡献。我已经实施了重新订购threadPoolExecutor 出于一个非常具体的目的，它能够明确地将执行人的阻塞器（在这种情况下为LinkedBlockingdeque）带到前面，而无需处理优先级（无论如何都可以导致僵局，并且无论如何是固定的）。

我正在使用它来管理（在Android应用程序中），我必须下载许多在长列表视图中显示的图像。每当用户迅速向下滚动时，执行人队列就会淹没图像下载请求：通过将最新的请求移动到队列的顶部，我在加载实际上在屏幕上的图像时取得了更好的性能，从而延迟了下载那些可能以后需要的。请注意，我使用内部并发地图密钥（可以像图像URL字符串一样简单）将任务添加到执行人，以便以后可以检索它们进行重新排序。

还有许多其他方法可以做同样的方法，也许已经过度复杂了，但是它在他的Android SDK中也可以正常工作，并且在Facebook上也可以在自己的工作线程排队中做类似的事情。

随意查看代码并给我建议，它在一个Android项目内部，但是剥离一些日志和注释会使纯Java 6级。

许可以下： CC-BY-SA 和归因

不隶属于 StackOverflow