ஆதாரங்களுடன் முயற்சி செய் அறிக்கை

"அமிகோ, பத்து குடிசை!"

"ஜாவா கற்றுக்கொண்டதில் மகிழ்ச்சி அடைகிறேன், கேப்டன்!"

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

"நான் எல்லாம் காதுகள்."

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

"அப்படியானால் என்ன உள் வளங்கள் கருதப்படுகின்றன?"

"உள் வளங்கள் என்பது ஜாவா இயந்திரத்திற்குள் உருவாக்கப்பட்ட பொருள்கள். பொதுவாக, தொடர்பு இந்த திட்டத்தைப் பின்பற்றுகிறது:

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

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

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

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

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

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

"அது நியாயமாகத் தெரிகிறது."

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

"இது எல்லா நினைவகத்தையும் தின்னும் புரோகிராம்கள் போல..."

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

"அது நல்ல செய்தி என்றால், கெட்ட செய்தி இருப்பதாக அர்த்தமா?"

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

"ஆனால் நான் அத்தகைய விண்ணப்பங்களை எழுதுகிறேனா?"

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

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

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

"மாதமாத நிலையான வேலையில் இது மிகவும் குறைவு! என்ன செய்யலாம்?"

"வெளிப்புற ஆதாரங்களைப் பயன்படுத்தும் வகுப்புகள் அவற்றை வெளியிடுவதற்கு ஒரு சிறப்பு முறையைக் கொண்டுள்ளன: close().

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

String path = "c:\\projects\\log.txt";
FileOutputStream output = new FileOutputStream(path);
output.write(1);
output.close();

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

ஆம்

"அது மிகவும் மோசமானது. என்ன செய்வது?"

"எப்பொழுதும் முறை அழைக்கப்படுவதை உறுதிசெய்ய , நமது குறியீட்டை ஒரு - - பிளாக்கில் வைத்து, அந்த முறையைத் தொகுதியில் சேர்க்க close()வேண்டும் . இது இப்படி இருக்கும்:trycatchfinallyclose()finally

try
{
   FileOutputStream output = new FileOutputStream(path);
   output.write(1);
   output.close();
}
catch (IOException e)
{
   e.printStackTrace();
}
finally
{
   output.close();
}

"ம்ம்... இங்க ஏதோ பிரச்சனையா?"

"சரி. இந்த குறியீடு தொகுக்கப்படாது, ஏனென்றால் outputதொகுதிக்குள் மாறி அறிவிக்கப்படுகிறது try{}, எனவே தொகுதியில் தெரியவில்லை finally.

சரி செய்வோம்:

FileOutputStream output = new FileOutputStream(path);

try
{
   output.write(1);
   output.close();
}
catch (IOException e)
{
   e.printStackTrace();
}
finally
{
   output.close();
}

"இப்போது எல்லாம் சரியாகிவிட்டதா?"

"பரவாயில்லை, ஆனால் நாம் FileOutputStreamபொருளை உருவாக்கும் போது பிழை ஏற்பட்டால் அது வேலை செய்யாது, இது மிகவும் எளிதாக நடக்கும்.

சரி செய்வோம்:

FileOutputStream output = null;

try
{
   output = new FileOutputStream(path);
   output.write(1);
   output.close();
}
catch (IOException e)
{
   e.printStackTrace();
}
finally
{
   output.close();
}

"இப்போது எல்லாம் வேலை செய்யுமா?"

"இன்னும் சில விமர்சனங்கள் உள்ளன. முதலில், பொருளை உருவாக்கும் போது பிழை ஏற்பட்டால் FileOutputStream, மாறி outputபூஜ்யமாக இருக்கும். இந்த சாத்தியத்தை பிளாக்கில் கணக்கிட வேண்டும் finally.

"இரண்டாவதாக, இந்த close()முறை எப்போதும் பிளாக்கில் அழைக்கப்படுகிறது finally, அதாவது தொகுதியில் அது தேவையில்லை try. இறுதி குறியீடு இப்படி இருக்கும்:

FileOutputStream output = null;

try
{
   output = new FileOutputStream(path);
   output.write(1);
}
catch (IOException e)
{
   e.printStackTrace();
}
finally
{
   if (output!=null)
      output.close();
}

"தவிர்க்கப்படக்கூடிய தொகுதியை நாங்கள் கருத்தில் கொள்ளாவிட்டாலும் catch, எங்கள் 3 கோடுகள் 10 ஆகிவிடும். ஆனால் நாங்கள் அடிப்படையில் கோப்பைத் திறந்து 1 என்று எழுதினோம்."

"ப்ச்சோ... விஷயத்தை முடிப்பது நல்ல விஷயம். ஒப்பீட்டளவில் புரியும், ஆனால் சற்றே சோர்வாக இருக்கிறது, இல்லையா?"

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

try-வளங்களுடன்

"அதன் 7வது பதிப்பில் தொடங்கி, ஜாவாவில் புதிய tryஆதாரங்களுடன் கூடிய அறிக்கை உள்ளது.

"முறைக்கான கட்டாய அழைப்பின் சிக்கலைத் தீர்க்க இது துல்லியமாக உருவாக்கப்பட்டது close()."

"இது நம்பிக்கைக்குரியதாக இருக்கிறது!"

"பொது வழக்கு மிகவும் எளிமையானது:

try (ClassName name = new ClassName())
{
   Code that works with the name variable
}

"எனவே இது அறிக்கையின் மற்றொரு மாறுபாடு try ? "

"ஆம். திறவுச்சொல்லுக்குப் பிறகு அடைப்புக்குறிகளைச் சேர்க்க வேண்டும் try, பின்னர் அடைப்புக்குறிக்குள் வெளிப்புற ஆதாரங்களைக் கொண்ட பொருட்களை உருவாக்க வேண்டும். அடைப்புக்குறிக்குள் உள்ள ஒவ்வொரு பொருளுக்கும், தொகுப்பி ஒரு finallyபகுதியையும் முறைக்கு அழைப்பையும் சேர்க்கிறது close().

"இரண்டு சமமான எடுத்துக்காட்டுகள் கீழே உள்ளன:

FileOutputStream output = null;

try
{
   output = new FileOutputStream(path);
   output.write(1);
}
finally
{
   if (output!=null)
   output.close();
}

try(FileOutputStream output = new FileOutputStream(path))
{
   output.write(1);
}

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

"நீங்கள் விரும்பியதில் மகிழ்ச்சி அடைகிறேன். மூலம், வளங்களுடன் கூடிய அறிக்கையை நாங்கள் சேர்க்கலாம் catchமற்றும் finallyதடுக்கலாம் try. அல்லது அவை தேவையில்லாமல் இருந்தால் அவற்றைச் சேர்க்க முடியாது.

ஒரே நேரத்தில் பல மாறிகள்

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

"இந்த நிலையில், try-with-resources அறிக்கையானது, அதில் ஒன்றை ஆனால் பல பொருட்களை உருவாக்க உங்களை அனுமதிக்கிறது. பொருள்களை உருவாக்கும் குறியீடு அரைப்புள்ளிகளால் பிரிக்கப்பட வேண்டும். இந்த அறிக்கையின் பொதுவான தோற்றம் இதோ:

try (ClassName name = new ClassName(); ClassName2 name2 = new ClassName2())
{
   Code that works with the name and name2 variables
}

கோப்புகளை நகலெடுப்பதற்கான எடுத்துக்காட்டு:

String src = "c:\\projects\\log.txt";
String dest = "c:\\projects\\copy.txt";

try(FileInputStream input = new FileInputStream(src);

FileOutputStream output = new FileOutputStream(dest))
{
   byte[] buffer = input.readAllBytes();
   output.write(buffer);
}

String src = "c:\\projects\\log.txt";
String dest = "c:\\projects\\copy.txt";

FileInputStream input = null;
FileOutputStream output = null;

try
{
   input = new FileInputStream(src);
   output = new FileOutputStream(dest);

   byte[] buffer = input.readAllBytes();
   output.write(buffer);
}
finally
{
   if (input!=null)
      input.close();
   if (output!=null)
      output.close();
}

"சரி, நாம் இங்கே என்ன சொல்ல முடியும்? try-வளங்களுடன் ஒரு அற்புதமான விஷயம்!"

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