The fork - join framework was presented in Java 7.

Arjun Sridhar UR:
 *DEEP DIVING IN TO JAVA* 

பிளவு  / சேர் ஜாவா 7 இல் இருந்து வழங்கப்பட்டது.

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

நடைமுறையில், இதன் அர்த்தம் கட்டமைப்பின் முதல் "சேர்"
அவைகள்  ஒத்தியங்காமல் (asynchronously) செயல்படும் / நிறைவேற்றப்படும் வரை. மீண்டும் மீண்டும் பணிகளை சிறிய சிறிய உபப் பணிகளாக  ஒவ்வொரு பணிகளும் சுதந்திரமாக செயல்படும் வரை உடைக்கும்.

-அதற்குப் பிறகு, "சேர்" பகுதி தொடங்குகிறது, இதில் அனைத்து உப பணிகளும் மறுபரிசீலனை செய்யப்பட்டு இணைத்து மொத்தமனாக வழங்கப்படும்,

அல்லது வெறுமை [void]திரும்பப்பெற வேண்டிய பணியின் விஷயத்தில், ஒவ்வொரு உப பணிகளும்[subtask] செயல்படுத்தப்படும் வரை நிரல் வெறுமனே காத்திருக்கிறது.

இணை செயல்பாடுகள்   செய்து முடித்தல் ,

பிளவு  / சேர் கட்டமைப்பு  Pool of thread டை உபயோகப்படுத்திக்கொள்ளும் அதன் பெயரே ForkJoinPool இவ் வகை தொழிலாளி thread/செயல்பாடுகளை ForkJoinWorkerThread மூலம் நிர்வகிக்கிறது .

_Pool of thread = செயல்கள் செயல் படும் இடம்_
*உதாரணம்:* கடலில் இருந்து மொத்தமாக பிடித்து வரும் கடல் மீன் வகைகளை  பிரிப்பது [fork] போன்று பிரித்து ஒவ்வொரு மீன் வகைகளையும் அதன் கூடைகளில் போடுவது  ForkJoinPool இதில் ஒருவர் மட்டும் பிரிக்க புடியாது என்பதால் பலா நபர்கள் வேலை செய்வார்கள் அவர்களை நாம் ForkJoinWorkerThread என்று அழைக்கிறோம் முடிவில் மீன்களை விற்க பிரித்ததை தனித்தனியாக கட்டி ஒரே வண்டியில் எடுத்து செய்வது execution என்று அழைக்கிறோம்.
இது ஏன் செய்கிறோம் என்றால் விற்கும் பொழுது பிரித்துக்கொண்டிருக்க முடியாது என்பதால் தான்.

The fork / join framework was presented in Java 7.

It provides tools to help speed up parallel processing by attempting to use all available processor cores – which is accomplished through a *divide* and *conquer* approach.

In practice, this means that the framework first “forks”,
recursively breaking the task into smaller independent subtasks until they are simple enough to be executed asynchronously.

After that, the “join” part begins, in which results of all subtasks are recursively joined into a single result,

or in the case of a task which returns void, the program simply waits until every subtask is executed.

To provide effective parallel execution,

the fork / join framework uses a pool of threads called the ForkJoinPool, which manages worker threads of type ForkJoinWorkerThread.

*NEXTGEN JAVA*
Arjun Sridhar UR
‍ +919941907755
_Whatsapp me to learn more_
_Join my whatsapp no in your group_