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

1. வெளி வளங்கள்

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

பொதுவாக, தொடர்பு இந்த திட்டத்தைப் பின்பற்றுகிறது:

ஆதாரங்களைக் கண்காணித்தல்

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

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

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

வெளிப்புற வளங்களைப் பெறுதல் .

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

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

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

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

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

2. close()முறை

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

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

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

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

விதிவிலக்குகள்

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

முறை எப்போதும் அழைக்கப்படுவதை உறுதிசெய்ய close(), நமது குறியீட்டை ஒரு try- catch- பிளாக்கில் வைத்து, அந்த முறையை பிளாக்கில் finallyசேர்க்க வேண்டும் . இது இப்படி இருக்கும்:close()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 என்று எழுதினோம். கொஞ்சம் சிரமமாக இருக்கிறது, இல்லையா?

3. 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);
}

-with-resources ஐப் பயன்படுத்தும் குறியீடு tryமிகவும் சிறியது மற்றும் படிக்க எளிதானது. எங்களிடம் குறைவான குறியீடு, எழுத்துப்பிழை அல்லது பிற பிழையை உருவாக்கும் வாய்ப்பு குறைவு.

மூலம், நாம் -with-resources அறிக்கையில் சேர்க்கலாம் catchமற்றும் finallyதடுக்கலாம் try. அல்லது தேவையில்லாமல் இருந்தால் சேர்க்க முடியாது.

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

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

இந்த வழக்கில், 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";

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();
}

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);
}

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

5. AutoCloseableஇடைமுகம்

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

tryஆனால் , வகுப்பில் முறை இல்லை என்றால், வளங்களுடன் கூடிய அறிக்கை எவ்வாறு செயல்படுகிறது close()? சரி, எதுவும் அழைக்கப்படாது என்று வைத்துக்கொள்வோம். முறை இல்லை, பிரச்சனை இல்லை.

tryஆனால் , வகுப்பில் பல close()முறைகள் இருந்தால் -with-resources அறிக்கை எவ்வாறு செயல்படுகிறது? மேலும் அவர்களுக்கு வாதங்கள் தேவையா? close()மற்றும் வகுப்பில் அளவுருக்கள் இல்லாமல் ஒரு முறை இல்லையா ?

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

இத்தகைய சிக்கல்களைத் தவிர்க்க, ஜாவாவின் படைப்பாளிகள் ஒரு சிறப்பு இடைமுகத்தைக் கொண்டு வந்தனர் AutoCloseable, அதில் ஒரே ஒரு முறை மட்டுமே உள்ளது — close(), எந்த அளவுருக்களும் இல்லை.

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

மூலம், அளவுருக்கள் இல்லாமல் அதன் சொந்த முறையைக் கொண்ட ஆனால் செயல்படுத்தாத tryஒரு பொருளை வளத்துடன் கூடிய அறிக்கை வளமாக அறிவிப்பது சாத்தியம் என்று நினைக்கிறீர்களா ?close()AutoCloseable

மோசமான செய்தி: சரியான பதில் இல்லை - வகுப்புகள் இடைமுகத்தை செயல்படுத்த வேண்டும் AutoCloseable.

நல்ல செய்தி: ஜாவாவில் இந்த இடைமுகத்தை செயல்படுத்தும் பல வகுப்புகள் உள்ளன, எனவே எல்லாம் சரியாக வேலை செய்யும்.