जावा

Question

में कार्य आदेश निष्पादन निर्दिष्ट करें मैंने बहुत कुछ खोजा है लेकिन कोई समाधान नहीं मिला। मैं इस तरह से थ्रेड पूल जावा का उपयोग करें:

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

इस तरह से कार्य में फलस्वरूप क्रम में क्रियान्वित कर रहे हैं (कतार में के रूप में)। लेकिन मुझे "अगले कार्य का चयन करें" रणनीति बदलने की जरूरत है। इसलिए मैं प्रत्येक कार्य को प्राथमिकता निर्दिष्ट करना चाहता हूं (यह थ्रेड प्राथमिकता नहीं है) और कार्य को निष्पादित करना इन प्राथमिकताओं से मेल खाता है। तो जब निष्पादक ने एक और कार्य पूरा कर लिया है तो यह कार्य को अधिकतम प्राथमिकता के साथ कार्य के रूप में चुनता है। यह सामान्य समस्या का वर्णन करता है। शायद वहां एक और सरल दृष्टिकोण है जो प्राथमिकताओं को खाता नहीं है। यह अंतिम जोड़ा गया कार्य के बजाय निष्पादित करने के बाद अंतिम जोड़ा गया कार्य का चयन करता है। निश्चित रूप से फिक्स्ड थ्रेडपूल फीफो रणनीति का उपयोग करते हुए बोलते हैं। क्या मैं उदाहरण के लिए लिफो रणनीति का उपयोग कर सकता हूं?

Answer 1

आप एक एलआईएफओ निष्पादक बनाना चाहते हैं? आशा इस सूत्र तुम बाहर

How to create LIFO executor

Answer 2

में मदद करता है आप ThreadPoolExecutor लिए कतार निर्दिष्ट करने के लिए PriorityBlockingQueue उपयोग कर सकते हैं।

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)); 
    } 
} 

प्राथमिकता की तुलना करने के लिए ComparableFutureTask परिभाषित करें।

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

थ्रेडपूल एक्स्सेलर कन्स्ट्रक्टर ब्लॉकिंगक्यूयू स्वीकार करता है। आप प्राथमिकताब्लॉकिंग्यूयू के रूप में कतार पास कर सकते हैं। यह आदेश देने के लिए आपको कस्टम तुलनाकर्ताओं को पारित करने की आवश्यकता के आदेश पर कोई अनुदान नहीं देता है।

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. 
    } 
}