நிறைவேற்றுபவர் சேவைகள்

நிறைவேற்றுபவர்

எக்ஸிகியூட்டர் என்பது இயங்கக்கூடிய பணிகளின் துவக்கத்தை செயல்படுத்தும் வகுப்புகளுக்கான அடிப்படை இடைமுகமாகும். இது ஒரு பணியைச் சேர்ப்பதற்கும் அதை எவ்வாறு தொடங்குவது என்பதற்கும் உதவி வழங்குகிறது.

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

invokeAll முறையானது பணிகளைச் செயல்படுத்துவதற்கும், பணிகளின் பட்டியலை அவற்றின் நிலை மற்றும் நிறைவு முடிவுகளுடன் வழங்குவதற்கும் பொறுப்பாகும்.

invokeAny முறையானது , பணிகளைச் செயல்படுத்துவதற்கும், வெற்றிகரமாக முடிக்கப்பட்ட பணியின் முடிவை (அதாவது, விதிவிலக்கு இல்லாமல்) வழங்குவதற்கும் பொறுப்பாகும்.

ScheduledExecutorService - இந்த இடைமுகமானது நிலுவையில் உள்ள பணிகளை ஒரு குறிப்பிட்ட காலதாமதத்துடன் அல்லது ஒரு குறிப்பிட்ட காலத்துடன் இயக்கும் திறனை சேர்க்கிறது.

AbstractExecutorService என்பது ExecutorService 'a'ஐ உருவாக்குவதற்கான ஒரு சுருக்க வகுப்பாகும். உள்ளே சமர்ப்பித்தல் , அனைத்து அழைப்பு , invokeAny முறைகள் செயல்படுத்தப்படுகிறது. இந்த வகுப்பு ThreadPoolExecutor , ScheduledThreadPoolExecutor மற்றும் ForkJoinPool ஆகியவற்றைப் பெறுகிறது .

public static void main(String[] args) {
   ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);
   Callable<String> task = () -> {
       System.out.println(Thread.currentThread().getName());
       return Thread.currentThread().getName();
   };
   scheduledExecutorService.schedule(task, 10, TimeUnit.SECONDS);
   scheduledExecutorService.shutdown();
}

ThreadPoolExecutor

Executors என்பது ThreadPoolExecutor , ScheduledThreadPoolExecutor ஐ உருவாக்குவதற்கான ஒரு தொழிற்சாலை வகுப்பாகும். இந்த குளங்களில் ஒன்றை நீங்கள் உருவாக்க வேண்டும் என்றால், இந்த தொழிற்சாலை உங்களுக்குத் தேவையானது. இதில் இயங்கக்கூடிய-அழைக்கக்கூடிய, சிறப்புரிமை-அழைப்பு-அழைக்கக்கூடிய, தனிச்சலுகை விதிவிலக்கு-அழைக்கக்கூடிய பல்வேறு அடாப்டர்கள் உள்ளன. வெவ்வேறு த்ரெட்பூலை உருவாக்குவதற்கான நிலையான முறைகள் உள்ளன.

ThreadPoolExecutor - Executor மற்றும் ExecutorService இடைமுகங்களைச் செயல்படுத்துகிறது மற்றும் பணிச் செயல்பாட்டிலிருந்து பணி உருவாக்கத்தைப் பிரிக்கிறது. நாம் இயக்கக்கூடிய பொருட்களைச் செயல்படுத்தி, அவற்றை நிறைவேற்றுபவருக்கு அனுப்ப வேண்டும், மேலும் அவற்றை செயல்படுத்துதல், உடனடிப்படுத்துதல் மற்றும் நூல்களுடன் வேலை செய்வதற்கு ThreadPoolExecutor பொறுப்பு.

ScheduledThreadPoolExecutor - ThreadPoolExecutor முறைகளுக்கு மேலதிகமாக, கொடுக்கப்பட்ட தாமதத்திற்குப் பிறகு அல்லது குறிப்பிட்ட காலச் செயல்பாட்டிற்கு கட்டளைகளை இயக்குவதற்குத் திட்டமிடக்கூடிய இழைகளின் தொகுப்பை இது உருவாக்குகிறது.

நூல் தொழிற்சாலைதேவைக்கேற்ப புதிய இழைகளை உருவாக்கும் ஒரு பொருளாகும். Executors.newSingleThreadExecutor (ThreadFactory threadFactory) முறைக்கு நாம் ஒரு உதாரணத்தை அனுப்ப வேண்டும் .

ExecutorService executorService = Executors.newSingleThreadExecutor(new ThreadFactory() {
 @Override public Thread newThread(Runnable r) {
Thread thread = new Thread(r, "MyThread");
thread.setPriority(Thread.MAX_PRIORITY);
 return thread; }
 });

RejectedExecutionHandler - சில காரணங்களால் ThreadPoolExecutor மூலம் செயல்படுத்த முடியாத பணிகளுக்கான ஹேண்ட்லரை வரையறுக்க உங்களை அனுமதிக்கிறது. இலவச ஸ்ட்ரீம்கள் இல்லாதபோது அல்லது சேவை நிறுத்தப்படும்போது அல்லது நிறுத்தப்படும்போது இது நிகழ்கிறது.

ThreadPoolExecutor வகுப்பில் பல நிலையான செயலாக்கங்கள் காணப்படுகின்றன :

• CallerRunsPolicy - அழைப்பு நூலில் ஒரு பணியை இயக்குகிறது;
• AbortPolicy - ஒரு விதிவிலக்கு;
• டிஸ்கார்ட் பாலிசி - பணியை புறக்கணிக்கிறது;
• டிஸ்கார்ட் ஓல்டெஸ்ட் பாலிசி - வரிசையிலிருந்து தொடங்கப்படாத பழைய பணியை அகற்றி, மீண்டும் புதிய பணியைச் சேர்க்க முயற்சிக்கும்.

நிறைவு சேவை

CompletionService என்பது ஒத்திசைவற்ற பணிகளைத் தொடங்கி முடிவுகளைப் பெறுவதற்கான ஒரு சேவை இடைமுகமாகும். பணிகளைச் சேர்க்க, சமர்ப்பிக்கும்முறைமற்றும் ஏற்கனவே முடிக்கப்பட்ட பணிகளின் முடிவுகளைப் பெற, ஒரு தடுப்புஎடுக்கும்மற்றும் தடுக்காதவாக்கெடுப்பு.

ExecutorCompletionService என்பது ThreadPoolExecutor அல்லது ForkJoinPool போன்ற எக்ஸிகியூட்டர் இடைமுகத்தை செயல்படுத்தும் எந்த வகுப்பிலும் ஒரு ரேப்பர் ஆகும். பணிகளைத் தொடங்குதல் மற்றும் அவற்றின் செயல்பாட்டைக் கட்டுப்படுத்தும் முறையிலிருந்து சுருக்கம் தேவைப்படும்போது இது பயன்படுத்தப்படுகிறது.

முடிக்கப்பட்ட பணிகள் இருந்தால், அவற்றை வெளியே இழுப்போம். பணிகள் எதுவும் இல்லை என்றால், ஏதாவது முடிவடையும் வரை நாங்கள் எடுத்துக்கொள்வோம். சேவையானது அதன் மையத்தில் LinkedBlockingQueue ஐப் பயன்படுத்துகிறது, ஆனால் நீங்கள் எந்த BlockingQueue செயலாக்கத்திலும் தேர்ச்சி பெறலாம்.