புதிய FixedThreadPool முறை

எக்ஸிகியூட்டர்ஸ் வகுப்பின் புதிய ஃபிக்ஸட் த்ரெட்பூல் முறையானது , குறிப்பிட்ட எண்ணிக்கையிலான இழைகளுடன் ஒரு எக்ஸிகியூட்டர் சேவையை உருவாக்குகிறது . newSingleThreadExecutor முறையைப் போலன்றி , பூலில் எத்தனை நூல்கள் வேண்டும் என்பதைக் குறிப்பிடுகிறோம். ஹூட்டின் கீழ், பின்வரும் குறியீடு அழைக்கப்படுகிறது:

new ThreadPoolExecutor(nThreads, nThreads,
                                      	0L, TimeUnit.MILLISECONDS,
                                      	new LinkedBlockingQueue());

corePoolSize ( எக்ஸிகியூட்டர் சேவை தொடங்கும் போது தயாராக இருக்கும் (தொடங்கும்) நூல்களின் எண்ணிக்கை ) மற்றும் அதிகபட்சம்PoolSize ( எக்ஸிகியூட்டர் சேவை உருவாக்கக்கூடிய அதிகபட்ச நூல்களின் எண்ணிக்கை ) அளவுருக்கள் ஒரே மதிப்பைப் பெறுகின்றன — புதிய ஃபிக்ஸட் த்ரெட்பூலுக்கு அனுப்பப்பட்ட நூல்களின் எண்ணிக்கை (nThreads) ) . நாம் அதே வழியில் ThreadFactory இன் சொந்த செயலாக்கத்தை அனுப்பலாம் .

சரி, நமக்கு ஏன் இப்படி ஒரு ExecutorService தேவை என்று பார்ப்போம் .

ஒரு நிலையான எண் (n) நூல்களைக் கொண்ட எக்ஸிகியூட்டர் சர்வீஸின் தர்க்கம் இங்கே :

• செயலாக்கப் பணிகளுக்கு அதிகபட்சம் n நூல்கள் செயலில் இருக்கும்.
• N க்கும் மேற்பட்ட பணிகள் சமர்ப்பிக்கப்பட்டால், நூல்கள் இலவசம் ஆகும் வரை அவை வரிசையில் வைக்கப்படும்.
• ஒரு நூல் தோல்வியடைந்து முடிவடையும் பட்சத்தில், அதன் இடத்தைப் பிடிக்க ஒரு புதிய நூல் உருவாக்கப்படும்.
• குளம் மூடப்படும் வரை குளத்தில் உள்ள எந்த நூலும் செயலில் இருக்கும்.

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

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

ஒரு குறிப்பிட்ட எண்ணிக்கையிலான நூல்களுடன் ExecutorService எவ்வாறு செயல்படுகிறது என்பதைப் பற்றிய நடைமுறைப் புரிதலைப் பெற பரிந்துரைக்கிறேன் . Runnable ஐ செயல்படுத்தும் வகுப்பை உருவாக்குவோம் . இந்த வகுப்பின் பொருள்கள் ExecutorService க்கான எங்கள் பணிகளைக் குறிக்கின்றன .

public class Task implements Runnable {
    int taskNumber;
 
    public Task(int taskNumber) {
        this.taskNumber = taskNumber;
    }
 
    @Override
    public void run() {
try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Processed user request #" + taskNumber + " on thread " + Thread.currentThread().getName());
    }
}
    

ரன் () முறையில், சில பணிச்சுமையை உருவகப்படுத்தி, நூலை 2 வினாடிகளுக்குத் தடுக்கிறோம், பின்னர் தற்போதைய பணியின் எண்ணையும் பணியைச் செயல்படுத்தும் நூலின் பெயரையும் காட்டுவோம்.

ExecutorService executorService = Executors.newFixedThreadPool(3);
 
        for (int i = 0; i < 30; i++) {
            executorService.execute(new Task(i));
        }
        
        executorService.shutdown();
    

தொடங்குவதற்கு, முக்கிய முறையில், நாங்கள் ஒரு ExecutorService ஐ உருவாக்கி , செயல்படுத்துவதற்கு 30 பணிகளைச் சமர்ப்பிக்கிறோம்.

கன்சோல் வெளியீடு, முந்தைய பணியால் விடுவிக்கப்பட்டவுடன், வெவ்வேறு த்ரெட்களில் பணிகள் எவ்வாறு செயல்படுத்தப்படுகின்றன என்பதைக் காட்டுகிறது.

இப்போது பணிகளின் எண்ணிக்கையை 100 ஆக அதிகரிப்போம், மேலும் 100 பணிகளைச் சமர்ப்பித்த பிறகு, காத்திருப்பு முடிவு(11, வினாடிகள்) முறையை அழைப்போம் . ஒரு எண் மற்றும் நேர அலகை வாதங்களாக அனுப்புகிறோம். இந்த முறை 11 வினாடிகளுக்கு முக்கிய நூலை தடுக்கும். அனைத்து பணிகளும் முடிவடையும் வரை காத்திருக்காமல் ExecutorService ஐ மூடுவதற்கு கட்டாயப்படுத்த shutdownNow() ஐ அழைப்போம் .

ExecutorService executorService = Executors.newFixedThreadPool(3);
 
        for (int i = 0; i < 100; i++) {
            executorService.execute(new Task(i));
        }
 
        executorService.awaitTermination(11, SECONDS);
 
        executorService.shutdownNow();
        System.out.println(executorService);
    

முடிவில், executorService இன் நிலையைப் பற்றிய தகவலைக் காண்பிப்போம் .

நாங்கள் பெறும் கன்சோல் வெளியீடு இங்கே:

இதைத் தொடர்ந்து 3 குறுக்கீடு விதிவிலக்குகள் , 3 செயலில் உள்ள பணிகளில் இருந்து தூக்க முறைகள் மூலம் எறியப்படும் .

நிரல் முடிவடையும் போது, ​​15 பணிகள் முடிந்துவிட்டன, ஆனால் குளத்தில் இன்னும் 3 செயலில் உள்ள நூல்கள் உள்ளன, அவை அவற்றின் பணிகளை முடிக்கவில்லை. குறுக்கீடு () முறை இந்த மூன்று த்ரெட்களில் அழைக்கப்படுகிறது, அதாவது பணி முடிவடையும், ஆனால் எங்கள் விஷயத்தில், தூக்க முறை ஒரு இடையூறு விதிவிலக்கை வீசுகிறது . shutdownNow() முறை அழைக்கப்பட்ட பிறகு, பணி வரிசை அழிக்கப்படுவதையும் காண்கிறோம் .

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

இங்கே மற்றொரு சுவாரசியமான கேள்வி: நீங்கள் ஒரு தொடரிழைக்கு எக்ஸிகியூட்டரைப் பயன்படுத்த வேண்டும் என்றால், நீங்கள் எந்த முறையை அழைக்க வேண்டும்? newSingleThreadExecutor() அல்லது newFixedThreadPool(1) ?

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