ThreadPoolExecutor

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

"நீங்கள் ஒரு விளையாட்டை எழுதுகிறீர்கள் என்றால், அது தனிப்பட்ட கதாபாத்திரங்கள் செய்யும் செயல்கள்."

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

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

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

"வேறு வார்த்தைகளில் கூறுவதானால், ஒரு நூலை உருவாக்குவது மற்றும் அழிப்பது பணியை விட அதிக நேரத்தையும் வளங்களையும் எடுக்கலாம்."

"ஜாவாவின் படைப்பாளிகள் இந்தப் பிரச்சனைக்கு நேர்த்தியான தீர்வைக் கொண்டு வந்தனர்: ThreadPoolExecutor .

" ThreadPoolExecutor என்பது உள்ளே இரண்டு விஷயங்களைக் கொண்ட ஒரு வகுப்பு:"

A)  ஒரு பணி வரிசை, நிரலில் அவை எழும்போது நீங்கள் பணியைச் சேர்க்கலாம்.

B) ஒரு நூல் குளம், இது இந்தப் பணிகளைச் செய்யும் நூல்களின் குழுவாகும்.

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

"நீங்கள் ஒரு ThreadPoolExecutor ஐ உருவாக்கும் போது , ​​நீங்கள் உருவாக்க வேண்டிய அதிகபட்ச நூல்களின் எண்ணிக்கையையும், வரிசைப்படுத்தக்கூடிய பணிகளின் அதிகபட்ச எண்ணிக்கையையும் அமைக்கலாம். வேறுவிதமாகக் கூறினால், நீங்கள் நூல்களின் எண்ணிக்கையை 10 ஆகக் கட்டுப்படுத்தலாம், எடுத்துக்காட்டாக, மற்றும் எண்ணிக்கை 100க்கு வரிசைப்படுத்தப்பட்ட பணிகள்."

" ThreadPoolExecutor இவ்வாறு செயல்படுகிறது:"

1)  நீங்கள் ஒரு புதிய பணியைச் சேர்க்கும்போது, ​​அது வரிசையின் முடிவில் வைக்கப்படும்.

2)  வரிசை நிரம்பியிருந்தால், விதிவிலக்கு போடப்படும்.

3)  ஒரு பணியை முடித்தவுடன், ஒவ்வொரு திரியும் அடுத்த பணியை வரிசையில் இருந்து எடுத்து அதை இயக்கத் தொடங்குகிறது.

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

"வேர்க்கர் த்ரெட்களின் எண்ணிக்கையை நாம் கட்டுப்படுத்தும் அணுகுமுறையானது, நம்மிடம் அதிக இழைகள் இருப்பதால், அவை ஒன்றுக்கொன்று குறுக்கிடுவதால் நன்மை பயக்கும். 5-10 தொழிலாளர் நூல்கள் மற்றும் நீண்ட வரிசை பணிகளை விட இது மிகவும் பயனுள்ளதாக இருக்கும். பணிகளின் எழுச்சிக்காக 100 நூல்களை உருவாக்கவும், அவை வளங்களுக்காக ஒன்றோடு ஒன்று போட்டியிடும்: நினைவகம், செயலி நேரம், தரவுத்தள அணுகல் போன்றவை."

" ThreadPoolExecutor இன் செயல்பாட்டின் உதாரணம் இதோ :"

ExecutorService service = Executors.newFixedThreadPool(2);

for(int i = 0; i < 10; i++)
{
 service.submit(new Runnable() {
    public void run()
    {
     // Here we download something big from the Internet.
    }
 });
}

"ஐயோ, நான் பார்க்கவில்லை..."

"புதிய FixedThreadPool முறை அழைக்கப்படும் போது ஒரு ThreadPoolExecutor பொருள் உருவாக்கப்படுகிறது."

எனவே, பயன்படுத்த மிகவும் எளிதானது. சமர்ப்பிக்கும் முறையுடன் ஒரு பணியைச் சேர்த்தவுடன், அது:

A)  உறங்கும் நூலை எழுப்புகிறது, ஒன்று இருந்தால், பணியைச் செயல்படுத்த.

B)  காத்திருப்பு நூல் இல்லை என்றால், அது பணிக்காக புதிய ஒன்றை உருவாக்குகிறது.

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

"இங்கே நாம் இணையத்தில் இருந்து பெரிய ஒன்றைப் பதிவிறக்குகிறோம்" என்பதை நான் வேண்டுமென்றே சேர்த்துள்ளேன். எங்களிடம் 100 பணிகள் இருந்தால் "இணையத்திலிருந்து பெரியதைப் பதிவிறக்கவும்", ஒரே நேரத்தில் பலவற்றை இயக்குவதில் அர்த்தமில்லை—நாங்கள்' எங்கள் இணைய இணைப்பின் அலைவரிசை வரம்பினால் தடுக்கப்படும். இந்த விஷயத்தில், இரண்டு நூல்கள் போதுமானதாக இருக்க வேண்டும். மேலே உள்ள எடுத்துக்காட்டில் நீங்கள் பார்ப்பது இதுதான்:"

ExecutorService service = Executors.newFixedThreadPool(2);

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

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