Java में ExecutorService क्या है और इसे कैसे बनाएं?

यह आलेख जावा में थ्रेड निर्माण और प्रबंधन की व्याख्या करने के लिए विभिन्न उदाहरणों के साथ जावा में एक्ज़ीक्यूटर सब-इंटरफ़ेस एक्ज़ीक्यूसर सर्विस की अवधारणा को शामिल करता है।

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

एक्ज़ीक्यूटर फ्रेमवर्क क्या है?

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





निष्पादक एक है किसी एप्लिकेशन में थ्रेड बनाने और प्रबंधित करने में आपकी सहायता करता है। द निम्नलिखित कार्यों में आपकी सहायता करता है।

  • थ्रेड क्रिएशन: यह थ्रेड्स के निर्माण के लिए कई तरह के तरीके प्रदान करता है जो आपके एप्लिकेशन को समवर्ती रूप से चलाने में मदद करता है।



  • थ्रेड मैनेजमेंट: यह थ्रेड जीवन चक्र का प्रबंधन भी करता है। निष्पादन के लिए कार्य सबमिट करने से पहले थ्रेड सक्रिय, व्यस्त या मृत होने पर आपको चिंता करने की आवश्यकता नहीं है।

  • टास्क सबमिशन एंड एक्ज़ीक्यूशन: एक्ज़ीक्यूटर फ्रेमवर्क थ्रेड पूल में टास्क सबमिशन के लिए तरीके प्रदान करता है, यह यह तय करने की शक्ति भी देता है कि थ्रेड निष्पादित किया जाएगा या नहीं।

java -edureka में निष्पादक-निष्पादक

ExecutorService जावा उदाहरण में

यह निष्पादक ढांचे का एक उप-इंटरफ़ेस है जो किसी अनुप्रयोग के थ्रेड जीवन चक्र को प्रबंधित करने के लिए कुछ कार्यक्षमताओं को जोड़ता है। यह एक सबमिट () विधि भी प्रदान करता है जो कि रन करने योग्य और कॉल करने योग्य दोनों को स्वीकार कर सकता है वस्तुएं।



निम्नलिखित उदाहरण में, हम एक एकल थ्रेड के साथ एक एक्सेकॉर्स सर्विस बनाएंगे और फिर थ्रेड के अंदर निष्पादित होने वाले कार्य को सबमिट करेंगे।

import java.util.concurrent.ExecutorService import java.util.concurrent.Executors public class उदाहरण {public static void main (String [] args) {System.out.println ('इनसाइड:' + Thread.currentThread ()। getName () )) System.out.println ('' ExecutorService बनाने ') ExecutorService execorservice = Executors.newSingleThreadExecutor () System.out.println (' एक रनवेबल बनाने के लिए) 'Runnable runnable = () -> {System.out.println (' अंदर) '+ Thread.currentThread ()। GetName ())} System.out.println (' कार्य को निष्पादन द्वारा निर्दिष्ट कार्य को निष्पादित करें ') execorservice.submit (runnable)}}
 आउटपुट: अंदर: मुख्य बनाने वाले एक्सक्यूसोर सर्विस को एक रनवेबल बनाकर, जो रनवेबल द्वारा निर्दिष्ट कार्य को अंदर निष्पादित करने के लिए प्रस्तुत करते हैं: पूल-1-थ्रेड -1

उपरोक्त दिखाता है कि हम कैसे एक ExecutorService बना सकते हैं और निष्पादक के अंदर एक कार्य निष्पादित कर सकते हैं। यदि कोई कार्य निष्पादन के लिए प्रस्तुत किया गया है और थ्रेड वर्तमान में किसी अन्य कार्य को निष्पादित करने में व्यस्त है, तो कार्य एक कतार में इंतजार करेगा जब तक कि थ्रेड इसे निष्पादित करने के लिए स्वतंत्र नहीं है।

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

जावा एक्ज़ीक्यूसर सर्विस कार्यान्वयन

ExecutorService एक थ्रेड पूल के समान है। वास्तव में, java.util.concurrent में ExecutorService का कार्यान्वयन पैकेज एक थ्रेडपूल कार्यान्वयन है। ExecutorService के java.util.concurrent पैकेज में निम्नलिखित कार्यान्वयन हैं:

ThreadPoolExecutor

ThreadPoolExecutor अपने आंतरिक रूप से पूल किए गए थ्रेड्स का उपयोग करके दिए गए कार्यों को निष्पादित करता है।

एक ThreadPoolExecutor बनाना

int corePoolSize = 5 int maxPoolSize = 10 लॉन्ग कीपएलाइवेटी = 5000 एक्सेक्यूटरसर्विस थ्रेडपूलExecutor = नया थ्रेडपूलExecutor (corePoolSize, maxPoolSize, KeepAliveTime, TimeUnit.MILLISECONDS, नया LinkedBlockingQueue) ()

शेड्यूल्डड्रेडपूल एक्सिक्यूटर

Java.util.concurrent.ScheduledThreadPoolExecutor एक ExecutorService है जो देरी के बाद चलने के लिए या प्रत्येक निष्पादन के बीच समय के एक निश्चित अंतराल के साथ बार-बार निष्पादित करने के लिए कार्यों को शेड्यूल कर सकता है।

उदाहरण

ScheduledExecutorService Schedexecutorservice = Executors.newScheduledThreadPool (5) ScheduledFuture Schedfuture = अनुसूचितExecutorService.schedule (नया कॉल करने योग्य () {सार्वजनिक कॉल () थ्रेड अपवाद {System.out.println ('निष्पादित') 'रिटर्न' नामक '5) {5}}। SECONDS)

एक्ज़ीक्यूसर सर्विस

किसी ExecutorService को कार्य सौंपने के लिए कुछ अलग तरीके हैं।

  • निष्पादित (चलाने योग्य)

  • सबमिट करें (चलाने योग्य)

  • invokeAny ()

  • invokeAll ()

निष्पादित करने योग्य

Java ExecutorService execute (Runnable) एक java.lang.Runnable ऑब्जेक्ट लेता है और इसे एसिंक्रोनस रूप से निष्पादित करता है।

ExecutorService execorService = Executors.newSingleThreadExecutor () execorService.execute (new Runnable () {public void run () {System.out.println ('asynchronous task')}}) execorService.shutdown ()

निष्पादन योग्य Runnable का परिणाम प्राप्त करने का कोई तरीका नहीं है, इसके लिए आपको Callable का उपयोग करना होगा।

Runnable सबमिट करें

Java ExecutorService सबमिट (Runnable) विधि एक Runnable कार्यान्वयन लेता है और एक भविष्य की वस्तु देता है। भविष्य की वस्तु का उपयोग यह जांचने के लिए किया जा सकता है कि क्या रननेबल ने निष्पादन समाप्त कर दिया है।

भविष्य का भविष्य = execorService.submit (नया Runnable () {public void run () {System.out.println (: asynchronous task ’)}}) future.get () // null अगर कार्य सही ढंग से समाप्त हो जाता है।

कॉल करने योग्य सबमिट करें

Java ExecutorService सबमिट (Callable) विधि सबमिट (Runnable) के समान है, लेकिन यह Runable के बजाय Java Callable लेता है।

भविष्य का भविष्य = execorService.submit (नया कॉल करने योग्य () {सार्वजनिक ऑब्जेक्ट कॉल () अपवाद अपवाद {System.out.println (chron एसिंक्रोनस कॉलेबल ’) 'Callable Result’}}) System.out.println (future Future.get) वापस करें ) = 'future.get ())
 आउटपुट: एसिंक्रोनस callable future.get = कॉल करने योग्य परिणाम

invokeAny ()

InvokeAny () विधि Callable ऑब्जेक्ट्स का संग्रह लेती है। इस विधि को लागू करने से कोई भविष्य नहीं लौटता है, लेकिन कॉल करने योग्य वस्तुओं में से एक का परिणाम देता है।

ExecutorService execorService = Executors.newSingleThreadExecutor () सेटcallables = नया हैशसेट() callables.add (नया Callable () {पब्लिक स्ट्रिंग कॉल () थ्रोसेप्शन {return'task A '}}) callables.add (नया कॉल करने योग्य () {पब्लिक स्ट्रिंग कॉल () थ्रेड एक्ससेप्शन (' Re'task B ') }) callables.add (नया कॉल करने योग्य () {सार्वजनिक स्ट्रिंग कॉल () थ्रेड अपवाद {return'task C '}}) स्ट्रिंग परिणाम = execorService.invokeAny (callables) System.out.println (' परिणाम = '+ परिणाम) निष्पादक सेवा ।बंद करना()

जब आप उपरोक्त कोड चलाते हैं, तो परिणाम बदल जाता है। यह टास्क ए, टास्क बी वगैरह हो सकता है।

InvokeAll ()

InvokeAll () विधि पैरामीटर के रूप में पारित सभी कॉल करने योग्य वस्तुओं को आमंत्रित करती है। यह भविष्य की वस्तुओं को लौटाता है जिसका उपयोग प्रत्येक कॉल करने योग्य के निष्पादन के परिणाम प्राप्त करने के लिए किया जा सकता है।

ExecutorService execorService = Executors.newSingleThreadExecutor () सेटcallables = नया हैशसेट() callables.add (नया कॉल करने योग्य () {पब्लिक स्ट्रिंग कॉल () थ्रेड अपवाद {रिटर्न} टास्क ए ’}}) callables.add (नया कॉल करने योग्य () {पब्लिक स्ट्रिंग कॉल () थ्रेड अपवाद है - return टास्क बी’} }) callables.add (नया कॉल करने योग्य () {सार्वजनिक स्ट्रिंग कॉल () अपवाद {{'C C}} लौटाता है) सूचीभविष्य (भविष्य के भविष्य के लिए) (निष्पादक) (भविष्य के भविष्य): {System.out.println ('future.get =' + future.get ())} execorService.shutdown ()

रननेबल बनाम कॉल करने योग्य

रनेबल और कॉल करने योग्य इंटरफेस एक-दूसरे से बहुत मिलते-जुलते हैं। की घोषणा में अंतर दिखाई दे रहा है इंटरफेस। दोनों इंटरफेस एक कार्य का प्रतिनिधित्व करते हैं जिसे थ्रेड या एक्सकसोरसेवर द्वारा समवर्ती रूप से निष्पादित किया जा सकता है।

कॉल करने योग्य घोषणा:

सार्वजनिक इंटरफ़ेस कॉल करने योग्य {सार्वजनिक ऑब्जेक्ट कॉल () अपवाद फेंकता}

चल घोषणा:

सार्वजनिक इंटरफ़ेस Runnable {सार्वजनिक शून्य रन ()}

दोनों के बीच मुख्य अंतर यह है कि कॉल () विधि विधि कॉल से किसी ऑब्जेक्ट को वापस कर सकती है। और कॉल () विधि एक फेंक सकते हैं चलाते समय () विधि नहीं कर सकते।

कमांड प्रॉम्प्ट का उपयोग करके जावा में क्लासपाथ कैसे सेट करें

कार्य रद्द करें

आप ExecutorService को सौंपे गए कार्य को रद्द कर सकते हैं, जब कार्य सौंपे जाने पर भविष्य में सबमिट की गई विधि को रद्द कर दें।

future.cancel ()

एग्ज़ेक्युरसेवर शटडाउन

निष्पादन पूर्ण होने के बाद भी थ्रेड्स को चालू रखने के लिए, आपको ExecutorService को बंद करना चाहिए।

बंद करना()

ExecutorService के अंदर थ्रेड को समाप्त करने के लिए आप शटडाउन () विधि को कॉल कर सकते हैं।

निष्पादक सेवा। शटडाउन ()

यह हमें इस लेख के अंत में लाता है, जहाँ हमने सीखा है कि कैसे हम ExecutorService का उपयोग किसी कार्य को निष्पादित करने के लिए कर सकते हैं। मुझे आशा है कि आप इस ट्यूटोरियल में आपके साथ साझा किए गए सभी के साथ स्पष्ट हैं।

यदि आपको यह लेख 'जावा में एक्जिक्यूटर सर्विस' पर मिला है, तो इसे देखें दुनिया भर में फैले 250,000 से अधिक संतुष्ट शिक्षार्थियों के नेटवर्क के साथ एक विश्वसनीय ऑनलाइन शिक्षण कंपनी।

हम यहां आपकी यात्रा में हर कदम पर आपकी मदद करने और एक पाठ्यक्रम के साथ आने के लिए तैयार हैं, जो छात्रों और पेशेवरों के लिए बनाया गया है, जो जावा डेवलपर बनना चाहते हैं। पाठ्यक्रम आपको जावा प्रोग्रामिंग में एक शुरुआत देने के लिए डिज़ाइन किया गया है और आपको विभिन्न के साथ कोर और उन्नत जावा अवधारणाओं दोनों के लिए प्रशिक्षित करता है पसंद सीतनिद्रा में होना और

यदि आप किसी भी प्रश्न के उत्तर में आते हैं, तो बेझिझक 'जावा में एक्जिक्यूटर सर्विस' के टिप्पणी अनुभाग में अपने सभी प्रश्न पूछें और हमारी टीम जवाब देने में प्रसन्न होगी।