निष्पादक सेवा इंटरफ़ेस

आपको एक्ज़ीक्यूटर इंटरफ़ेस की आवश्यकता क्यों है?

जावा 5 से पहले, आपको अपने आवेदन में अपना खुद का कोड थ्रेड प्रबंधन लिखना था। इसके अलावा, एक बनानानया सूत्रऑब्जेक्ट एक संसाधन-गहन ऑपरेशन है, और हर हल्के कार्य के लिए एक नया धागा बनाने का कोई मतलब नहीं है। और क्योंकि यह समस्या बहु-थ्रेडेड एप्लिकेशन के हर डेवलपर से परिचित है, इसलिए उन्होंने इस कार्यक्षमता को एक्ज़ीक्यूटर फ्रेमवर्क के रूप में जावा में लाने का फैसला किया।

बड़ा विचार क्या है? यह सरल है: प्रत्येक नए कार्य के लिए एक नया थ्रेड बनाने के बजाय, थ्रेड्स को एक प्रकार के "स्टोरेज" में रखा जाता है, और जब कोई नया कार्य आता है, तो हम एक नया बनाने के बजाय मौजूदा थ्रेड को पुनः प्राप्त करते हैं।

इस ढांचे के मुख्य इंटरफेस एक्ज़ीक्यूटर , एक्ज़ीक्यूटर सर्विस और शेड्यूल्ड एक्ज़ीक्यूटर सर्विस हैं , जिनमें से प्रत्येक पिछले एक की कार्यक्षमता का विस्तार करता है।

एक्ज़ीक्यूटर इंटरफ़ेस बेस इंटरफ़ेस है। यह एक एकल शून्य निष्पादन (रननेबल कमांड) विधि की घोषणा करता है जिसे रननेबल ऑब्जेक्ट द्वारा कार्यान्वित किया जाता है।

ExecutorService इंटरफ़ेस अधिक दिलचस्प है । इसमें काम पूरा होने के प्रबंधन के तरीके हैं, साथ ही किसी प्रकार के परिणाम वापस करने के तरीके भी हैं। आइए इसके तरीकों पर करीब से नज़र डालें:

आइए निष्पादक सेवा के साथ काम करने का एक छोटा सा उदाहरण देखें ।

import java.util.List;
import java.util.concurrent.*;

public class ExecutorServiceTest {
   public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
//Create an ExecutorService for 2 threads
       java.util.concurrent.ExecutorService executorService = new ThreadPoolExecutor(2, 2, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(10));
// Create 5 tasks
       MyRunnable task1 = new MyRunnable();
       MyRunnable task2 = new MyRunnable();
       MyRunnable task3 = new MyRunnable();
       MyRunnable task4 = new MyRunnable();
       MyRunnable task5 = new MyRunnable();

       final List<MyRunnable> tasks = List.of(task1, task2, task3, task4, task5);
// Pass a list that contains the 5 tasks we created
       final List<Future<Void>> futures = executorService.invokeAll(tasks, 6, TimeUnit.SECONDS);
       System.out.println("Futures received");

// Stop the ExecutorService
       executorService.shutdown();

       try {
           TimeUnit.SECONDS.sleep(3);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }

       System.out.println(executorService.isShutdown());
       System.out.println(executorService.isTerminated());
   }

   public static class MyRunnable implements Callable<Void> {

       @Override
       public void call() {
// Add 2 delays. When the ExecutorService is stopped, we will see which delay is in progress when the attempt is made to stop execution of the task
           try {
               TimeUnit.SECONDS.sleep(3);
           } catch (InterruptedException e) {
               System.out.println("sleep 1: " + e.getMessage());
           }
           try {
               TimeUnit.SECONDS.sleep(2);
           } catch (InterruptedException e) {
               System.out.println("sleep 2: " + e.getMessage());
           }
           System.out.println("done");
           return null;
       }
   }
}

आउटपुट:

प्रत्येक कार्य 5 सेकंड के लिए चलता है। हमने दो धागों के लिए एक पूल बनाया है, इसलिए आउटपुट की पहली दो पंक्तियाँ सही समझ में आती हैं।

कार्यक्रम शुरू होने के छह सेकंड बाद, इनवॉकऑल विधि का समय समाप्त हो जाता है और परिणाम फ्यूचर्स की सूची के रूप में वापस आ जाता है । इसे प्राप्त आउटपुट स्ट्रिंग Futures से देखा जा सकता है ।

पहले दो काम पूरे होने के बाद दो और शुरू होते हैं। लेकिन क्योंकि इनवोकएल विधि में निर्धारित समय समाप्त हो गया है, इन दो कार्यों को पूरा करने का समय नहीं है। उन्हें "रद्द करें" आदेश प्राप्त होता है। इसलिए आउटपुट में स्लीप 1: स्लीप इंटरप्टेड के साथ दो लाइनें हैं ।

और फिर आप दो और पंक्तियों को did के साथ देख सकते हैं । यह वह साइड इफेक्ट है जिसका मैंने इनवोकअल विधि का वर्णन करते समय उल्लेख किया था।

पाँचवाँ और अंतिम कार्य कभी भी शुरू नहीं होता है, इसलिए हम इसके बारे में आउटपुट में कुछ भी नहीं देखते हैं।

आखिरी दो पंक्तियां शटडाउन और टर्मिनेटेड विधियों को कॉल करने का परिणाम हैं।

इस उदाहरण को डिबग मोड में चलाना भी दिलचस्प है और समय समाप्त होने के बाद कार्य की स्थिति को देखें ( निष्पादक सेवा.शटडाउन (); के साथ लाइन पर ब्रेकपॉइंट सेट करें ):

हम देखते हैं कि दो कार्य सामान्य रूप से पूर्ण हुए , और तीन कार्य "रद्द" हुए ।

अनुसूचित निष्पादक सेवा

निष्पादकों की हमारी चर्चा को समाप्त करने के लिए, आइए एक नज़र डालते हैं ScheduledExecutorService पर ।

इसकी 4 विधियाँ हैं: