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

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

ஒரு நூல் குளம் மற்றும் ThreadPoolExecutor இங்கே எங்கள் உதவிக்கு வருகிறது.

நூல் குளம் என்பது முன் தொடங்கப்பட்ட நூல்களின் தொகுப்பாகும். அதன் அளவு நிலையானதாகவோ அல்லது மாறக்கூடியதாகவோ இருக்கலாம்.

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

ThreadPoolExecutor

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

Java webinar

முக்கிய இடைமுகங்கள் எக்ஸிகியூட்டர் மற்றும் எக்ஸிகியூட்டர் சர்வீஸ் ஆகும் .

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

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

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

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

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

ThreadPoolExecutor 4 கட்டமைப்பாளர்களைக் கொண்டுள்ளது:


ThreadPoolExecutor(
int corePoolSize,
int maximumPoolSize,
long keepAliveTime, 
TimeUnit unit, 
BlockingQueue<Runnable> workQueue)
    

ThreadPoolExecutor(
int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler)
    

ThreadPoolExecutor(
int corePoolSize,
int maximumPoolSize,
long keepAliveTime, 
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory)
    

ThreadPoolExecutor(
int corePoolSize,
int maximumPoolSize,
long keepAliveTime, 
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory, 
RejectedExecutionHandler handler)

ThreadPoolExecutor கட்டமைப்பாளர் பின்வரும் அளவுருக்களைக் கொண்டுள்ளது :

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

ஒரு ThreadPoolExecutor ஐ உருவாக்குதல்

எக்ஸிகியூட்டர்ஸ் பயன்பாட்டு வகுப்பு ஒரு ThreadPoolExecutor ஐ உருவாக்குவதை எளிதாக்குகிறது . இந்த பயன்பாட்டு வகுப்பின் முறைகள் a தயார் செய்ய நமக்கு உதவுகின்றனThreadPoolExecutorபொருள்.

newFixedThreadPool - ஒரு நூல் குளத்தை உருவாக்குகிறது, இது எந்த எண்ணிக்கையிலான பணிகளையும் செயல்படுத்த நிலையான எண்ணிக்கையிலான நூல்களை மீண்டும் பயன்படுத்துகிறது. 

ExecutorService executor = Executors.newFixedThreadPool(10);
newWorkStealingPool — JVM க்கு கிடைக்கும் ப்ராசசர் கோர்களின் எண்ணிக்கைக்கு சமமான நூல்களின் எண்ணிக்கை இருக்கும் இடத்தில் ஒரு நூல் குளத்தை உருவாக்குகிறது. இயல்புநிலை ஒத்திசைவு நிலை ஒன்று. இதன் அர்த்தம், JVM க்கு CPU கோர்கள் உள்ளதைப் போல பல த்ரெட்கள் பூலில் உருவாக்கப்படும். ஒத்திசைவு நிலை 4 ஆக இருந்தால், கோர்களின் எண்ணிக்கைக்குப் பதிலாக அனுப்பப்பட்ட மதிப்பு பயன்படுத்தப்படும். 

ExecutorService executor = Executors.newWorkStealingPool(4);
newSingleThreadExecutor - அனைத்து பணிகளையும் செயல்படுத்த ஒற்றை நூல் கொண்ட ஒரு குளத்தை உருவாக்குகிறது. 

ExecutorService executor = Executors.newSingleThreadExecutor();
newCachedThreadPool — தேவைக்கேற்ப புதிய இழைகளை உருவாக்கும் ஒரு த்ரெட் பூலை உருவாக்குகிறது, ஆனால் முன்பு உருவாக்கப்பட்ட இழைகள் கிடைக்கும்போது அவற்றை மீண்டும் பயன்படுத்துகிறது. 

ExecutorService executor = Executors.newCachedThreadPool();
newScheduledThreadPool — கொடுக்கப்பட்ட தாமதத்திற்குப் பிறகு அல்லது அவ்வப்போது கட்டளைகளை இயக்குவதற்குத் திட்டமிடக்கூடிய ஒரு நூல் தொகுப்பை உருவாக்குகிறது. 

ScheduledExecutorService executor = Executors.newScheduledThreadPool(10);

பின்வரும் பாடங்களில் ஒவ்வொரு வகை குளங்களையும் கருத்தில் கொள்வோம்.