Określanie kolejności wykonywania zadań w Javie

Question

Szukałem dużo, ale nie mogłem znaleźć rozwiązania. użyć javy puli wątków w taki sposób:

ExecutorService c = Executors.newFixedThreadPool(3); 
for (int i = 0; i < 10; ++i) { 
    c.execute(new MyTask(i)); 
} 

w ten sposób zadania są wykonywane w konsekwencji kolejności (jak w kolejce). Ale potrzebuję zmiany strategii "wybierz następne zadanie". Dlatego chcę przypisać do każdego zadania określić priorytet (nie jest to priorytet wątku), a zadania wykonania odpowiadają tym priorytetom. Tak więc, gdy wykonawca zakończył inne zadanie, wybiera następne zadanie jako zadanie o najwyższym priorytecie. Opisano typowy problem. Być może istnieje prostsze podejście, które nie uwzględnia priorytetów. Wybiera ostatnie dodane zadanie jako obok wykonania zamiast pierwszego dodanego. Z grubsza rzecz biorąc FixedThreadPool wykorzystuje strategię FIFO. Czy mogę użyć np. Strategii LIFO?

Answer 1

Chcesz utworzyć executor LIFO? Nadzieja ten wątek pomaga się

How to create LIFO executor

Answer 2

Można użyć PriorityBlockingQueue określić kolejkę do ThreadPoolExecutor.

public class PriorityExecutor extends ThreadPoolExecutor { 

    public PriorityExecutor(int corePoolSize, int maximumPoolSize, 
      long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) { 
     super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue); 
    } 
    //Utitlity method to create thread pool easily 
    public static ExecutorService newFixedThreadPool(int nThreads) { 
     return new PriorityExecutor(nThreads, nThreads, 0L, 
       TimeUnit.MILLISECONDS, new PriorityBlockingQueue<Runnable>()); 
    } 
    //Submit with New comparable task 
    public Future<?> submit(Runnable task, int priority) { 
     return super.submit(new ComparableFutureTask(task, null, priority)); 
    } 
    //execute with New comparable task 
    public void execute(Runnable command, int priority) { 
     super.execute(new ComparableFutureTask(command, null, priority)); 
    } 
} 

Definiowanie ComparableFutureTask porównać priorytecie.

class ComparableFutureTask<T> extends FutureTask<T> 
     implements 
      Comparable<ComparableFutureTask<T>> { 

    volatile int priority = 0; 

    public ComparableFutureTask(Runnable runnable, T result, int priority) { 
     super(runnable, result); 
     this.priority = priority; 
    } 
    public ComparableFutureTask(Callable<T> callable, int priority) { 
     super(callable); 
     this.priority = priority; 
    } 
    @Override 
    public int compareTo(ComparableFutureTask<T> o) { 
     return Integer.valueOf(priority).compareTo(o.priority); 
    } 
    } 

Answer 3

ThreadPoolExecutor constructor przyjmuje BlockingQueue. Możesz przekazać kolejkę jako PriorityBlockingQueue. Nie ma żadnych stypendystów, którzy muszą przekazać niestandardowe komparatory, aby utrzymać porządek.

static BlockingQueue<Task> queue=new PriorityBlockingQueue<Task>(MAXPOOL,new TaskComparator()); 

static ThreadPoolExecutor threadpool = new ThreadPoolExecutor(30, MAXPOOL, 
     MAXPOOL, TimeUnit.SECONDS, (PriorityBlockingQueue) queue, new mThreadFactory()); 



class TaskComparator implements Comparator<Task>{ 
    public int compare(Task t1, Task t2){ 
    //write you own logic to compare two task. 
    } 
}