join — ஒரு நூல் முடிவடையும் வரை காத்திருக்கிறது

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

"இது மிகவும் கடினமாக இல்லை."

நன்றாக இருக்கிறது! இன்று உங்களுக்கு எளிதான பாடம் உள்ளது, மேலும் தலைப்பு சேரும் முறை.

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

நல்ல கேள்வி. முக்கிய நூல் என்ன செய்ய வேண்டும்?

"இதற்குத்தான் சேரும் முறை. இது ஒரு நூலை அதன் வேலையை முடிக்கும்போது காத்திருக்க வைக்க அனுமதிக்கிறது:"

class Printer implements Runnable
{
private String name;
public Printer(String name)
{
this.name = name;
}
public void run()
{
System.out.println("I’m " + this.name);
}
}

public static void main(String[] args)
{
Printer printer1 = new Printer("Nick");
Thread thread1 = new Thread(printer1);
thread1.start();

thread1.join();
}

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

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

"அவ்வளவுதான்?"

"ஆம்."

"ஆனால் நாம் ஏன் ஒரு நூலை உருவாக்க வேண்டும், பின்னர் அது முடிவடையும் வரை உடனடியாக காத்திருக்க வேண்டும்?"

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

"அறிந்துகொண்டேன்."