புதிய திட்டமிடப்பட்ட த்ரெட்பூல் முறை

மற்றொரு வகை பணிக் குளம் திட்டமிடப்பட்ட பணிக் குளம் ஆகும். பெயரை வைத்து ஆராயும்போது, ​​ஒரு குறிப்பிட்ட பணி எப்போது தொடங்கப்பட வேண்டும் என்பதை திட்டமிட இந்த வகையைப் பயன்படுத்துகிறோம் என்று வைத்துக் கொள்ளலாம்.

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

ஒன்றைப் பயன்படுத்த, நாங்கள் Executors.newScheduledThreadPool(1) என்று அழைக்கிறோம் .

அளவுருக்கள் பற்றி சிறிது நேரம் கழித்து பேசுவோம். ஆனால் இப்போதைக்கு, நாம் தெரிந்து கொள்ள வேண்டியது என்னவென்றால், இந்த முறை என்று அழைக்கப்படும் போது நமக்கு ஒரு ScheduledExecutorService ஆப்ஜெக்ட் கிடைக்கும்.

ScheduledExecutorService என்பது ExecutorServiceஐ நீட்டிக்கும் இடைமுகமாகும்.

இந்த இடைமுகத்தில் பின்வரும் முறைகள் தோன்றும்:

ScheduledFuture<?>
schedule(Runnable command,
                                  long delay, TimeUnit unit);

<V> ScheduledFuture<V>
schedule(Callable<V> callable,
                                      long delay, TimeUnit unit);

ScheduledFuture<?>
scheduleAtFixedRate(Runnable command,
                                             long initialDelay,
                                             long period,
                                             TimeUnit unit);

ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                long initialDelay,
                                                long delay,
                                                TimeUnit unit);

எனவே இடைமுகம் வழக்கமான இடைவெளியில் அல்லது சிறிது தாமதத்திற்குப் பிறகு பணிகளை இயக்க அனுமதிக்கிறது.

புதிய ScheduledThreadPool முறையைப் பற்றி மேலும்.

நாம் பல வழிகளில் அழைக்கலாம்:

newScheduledThreadPool(int corePoolSize)

newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)

இரண்டு முறைகளும் ஒரு குறிப்பிட்ட தாமதத்திற்குப் பிறகு அல்லது குறிப்பிட்ட கால இடைவெளிக்குப் பிறகு செயல்களைத் திட்டமிடக்கூடிய ஒரு நூல் தொகுப்பை உருவாக்கும்.

ScheduledThreadPool எவ்வாறு செயல்படுகிறது என்பதைப் பார்க்க ஒரு உதாரணத்தைப் பார்ப்போம் .

எடுத்துக்காட்டாக, ஒவ்வொரு 5 வினாடிகளுக்கும் மின்னஞ்சலைச் சரிபார்க்கும் பணி எங்களிடம் உள்ளது என்று வைத்துக்கொள்வோம், ஆனால் இந்தச் சரிபார்ப்பு முக்கிய நிரலைப் பாதிக்கக்கூடாது மற்றும் கூடுதல் ஆதாரங்களின் சாத்தியமான நுகர்வுகளை ஏற்படுத்துகிறது.

மின்னஞ்சலைச் சரிபார்ப்பதை உருவகப்படுத்தும் பணி வகுப்பு எங்களிடம் உள்ளது.

public class Task implements Runnable {
   @Override
   public void run() {
       System.out.println("Checking email...");
   }
}

அடுத்து, நாங்கள் ஒரு நூல் குளத்தை உருவாக்கி, காசோலையை திட்டமிடுகிறோம்.

ScheduledExecutorService executorService = Executors.newScheduledThreadPool(2);
executorService.scheduleAtFixedRate(new Task(), 0, 5, TimeUnit.SECONDS);

வெளியீட்டில், ஒவ்வொரு 5 வினாடிகளிலும் நாம் பார்க்கிறோம்:

பொதுவாக, எடுத்துக்காட்டில் உள்ளதைப் போல, குறிப்பிட்ட கால இடைவெளியில் "ஹவுஸ் கீப்பிங்" பணிகளைச் செய்ய அத்தகைய குளத்தைப் பயன்படுத்தலாம். வீட்டு பராமரிப்பு பணிகள் முக்கிய நிரல் என்ன செய்தாலும் செய்ய வேண்டிய பணிகள்.