ExecutorService இடைமுகம்

உங்களுக்கு எக்ஸிகியூட்டர் இடைமுகம் ஏன் தேவை?

ஜாவா 5 க்கு முன், உங்கள் பயன்பாட்டில் உங்கள் சொந்த குறியீடு நூல் மேலாண்மை அனைத்தையும் எழுத வேண்டும். கூடுதலாக, உருவாக்குதல் ஏபுதிய நூல்ஆப்ஜெக்ட் என்பது ஒரு வள-தீவிர செயல்பாடாகும், மேலும் ஒவ்வொரு இலகுவான பணிக்கும் ஒரு புதிய நூலை உருவாக்குவதில் அர்த்தமில்லை. மல்டி-த்ரெட் அப்ளிகேஷன்களின் ஒவ்வொரு டெவலப்பருக்கும் இந்த சிக்கல் நன்கு தெரிந்திருப்பதால், இந்த செயல்பாட்டை ஜாவாவில் எக்ஸிகியூட்டர் கட்டமைப்பாகக் கொண்டு வர அவர்கள் முடிவு செய்தனர் .

என்ன பெரிய யோசனை? இது எளிதானது: ஒவ்வொரு புதிய பணிக்கும் ஒரு புதிய நூலை உருவாக்குவதற்குப் பதிலாக, நூல்கள் ஒரு வகையான "சேமிப்பகத்தில்" வைக்கப்படுகின்றன, மேலும் புதிய பணி வரும்போது, ​​புதிய ஒன்றை உருவாக்குவதற்குப் பதிலாக ஏற்கனவே உள்ள நூலை மீட்டெடுக்கிறோம்.

இந்த கட்டமைப்பின் முக்கிய இடைமுகங்கள் எக்ஸிகியூட்டர் , எக்ஸிகியூட்டர் சர்வீஸ் மற்றும் ஷெட்யூல்டு எக்ஸிகியூட்டர் சர்வீஸ் ஆகும் , இவை ஒவ்வொன்றும் முந்தைய செயல்பாட்டின் செயல்பாட்டை நீட்டிக்கிறது.

எக்ஸிகியூட்டர் இடைமுகம் அடிப்படை இடைமுகம். இது இயங்கக்கூடிய பொருளால் செயல்படுத்தப்படும் ஒற்றை வெற்றிடத்தை இயக்கும் (இயக்கக்கூடிய கட்டளை) முறையை அறிவிக்கிறது .

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

இரண்டு பணிகள் சாதாரணமாக முடிந்ததையும் , மூன்று பணிகள் "ரத்து" செய்யப்பட்டதையும் காண்கிறோம் .

திட்டமிடப்பட்ட நிறைவேற்று சேவை

நிறைவேற்றுபவர்கள் பற்றிய எங்கள் விவாதத்தை முடிக்க, ScheduledExecutorService ஐப் பார்ப்போம் .

இது 4 முறைகளைக் கொண்டுள்ளது: