एक्झिक्युटर सर्व्हिस इंटरफेस

तुम्हाला एक्झिक्युटर इंटरफेसची गरज का आहे?

Java 5 च्या आधी, तुम्हाला तुमच्या ऍप्लिकेशनमध्ये तुमचे स्वतःचे सर्व कोड थ्रेड व्यवस्थापन लिहावे लागले. याव्यतिरिक्त, तयार करणे एनवीन धागाऑब्जेक्ट एक संसाधन-केंद्रित ऑपरेशन आहे, आणि प्रत्येक हलक्या कार्यासाठी नवीन धागा तयार करण्यात अर्थ नाही. आणि ही समस्या मल्टी-थ्रेडेड ऍप्लिकेशन्सच्या प्रत्येक विकसकाला परिचित असल्याने, त्यांनी ही कार्यक्षमता जावामध्ये एक्झिक्युटर फ्रेमवर्क म्हणून आणण्याचा निर्णय घेतला.

मोठी कल्पना काय आहे? हे सोपे आहे: प्रत्येक नवीन कार्यासाठी नवीन धागा तयार करण्याऐवजी, थ्रेड एका प्रकारच्या "स्टोरेज" मध्ये ठेवले जातात आणि जेव्हा नवीन कार्य येते, तेव्हा आम्ही नवीन तयार करण्याऐवजी विद्यमान थ्रेड पुनर्प्राप्त करतो.

या फ्रेमवर्कचे मुख्य इंटरफेस आहेत Executor , ExecutorService आणि ScheduledExecutorService , त्यापैकी प्रत्येक मागील एकाची कार्यक्षमता वाढवते.

एक्झिक्युटर इंटरफेस हा बेस इंटरफेस आहे. हे एकल व्हॉइड एक्झिक्यूट (रन करण्यायोग्य कमांड) पद्धत घोषित करते जी रन करण्यायोग्य ऑब्जेक्टद्वारे लागू केली जाते.

ExecutorService इंटरफेस अधिक मनोरंजक आहे . त्यात काम पूर्ण करण्याच्या पद्धती तसेच काही प्रकारचे परिणाम परत करण्याच्या पद्धती आहेत. चला त्याच्या पद्धतींचा बारकाईने विचार करूया:

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 सेकंद चालते. आम्ही दोन थ्रेडसाठी एक पूल तयार केला आहे, त्यामुळे आउटपुटच्या पहिल्या दोन ओळी अचूक अर्थ देतात.

प्रोग्रॅम सुरू झाल्यानंतर सहा सेकंदांनंतर, सर्व पद्धतीची वेळ संपते आणि निकाल फ्यूचर्सची सूची म्हणून परत केला जातो . हे प्राप्त झालेल्या आउटपुट स्ट्रिंगमधून पाहिले जाऊ शकते .

पहिली दोन कामे पूर्ण झाल्यानंतर आणखी दोन सुरू होतात. परंतु invokeAll पद्धतीमध्ये सेट केलेली कालबाह्यता संपल्यामुळे, या दोन कार्यांना पूर्ण होण्यासाठी वेळ नाही. त्यांना "रद्द" आदेश प्राप्त होतो. म्हणूनच आउटपुटमध्ये स्लीप 1 सह दोन ओळी आहेत: स्लीप इंटरप्टेड .

आणि नंतर आपण पूर्ण सह आणखी दोन ओळी पाहू शकता . invokeAll पद्धतीचे वर्णन करताना मी नमूद केलेला हा दुष्परिणाम आहे .

पाचवे आणि अंतिम कार्य कधीच सुरू होत नाही, म्हणून आम्हाला आउटपुटमध्ये याबद्दल काहीही दिसत नाही.

शेवटच्या दोन ओळी isShutdown आणि isTerminated पद्धती कॉल केल्याचा परिणाम आहे .

हे उदाहरण डीबग मोडमध्ये चालवणे आणि कालबाह्य झाल्यानंतर कार्य स्थिती पाहणे देखील मनोरंजक आहे ( executorService.shutdown() सह लाइनवर ब्रेकपॉइंट सेट करा ):

आपण पाहतो की दोन कार्ये सामान्यपणे पूर्ण झाली आहेत आणि तीन कार्ये "रद्द" झाली आहेत .

शेड्यूल्ड एक्झिक्यूटरसेवा

एक्झिक्युटर्सबद्दलची आमची चर्चा पूर्ण करण्यासाठी, शेड्युल्डएक्सेक्युटरसर्व्हिसवर एक नजर टाकूया .

त्याच्या 4 पद्धती आहेत: