వనరులతో ప్రయత్నించండి ప్రకటన

1. బాహ్య వనరులు

జావా ప్రోగ్రామ్ నడుస్తున్నప్పుడు, కొన్నిసార్లు ఇది జావా మెషీన్ వెలుపల ఉన్న ఎంటిటీలతో సంకర్షణ చెందుతుంది. ఉదాహరణకు, డిస్క్‌లోని ఫైల్‌లతో. ఈ ఎంటిటీలను సాధారణంగా బాహ్య వనరులు అంటారు. అంతర్గత వనరులు జావా యంత్రం లోపల సృష్టించబడిన వస్తువులు.

సాధారణంగా, పరస్పర చర్య ఈ పథకాన్ని అనుసరిస్తుంది:

ట్రాకింగ్ వనరులు

ఆపరేటింగ్ సిస్టమ్ అందుబాటులో ఉన్న వనరులను కఠినంగా ట్రాక్ చేస్తుంది మరియు వివిధ ప్రోగ్రామ్‌ల నుండి వాటికి భాగస్వామ్య ప్రాప్యతను కూడా నియంత్రిస్తుంది. ఉదాహరణకు, ఒక ప్రోగ్రామ్ ఫైల్‌ను మార్చినట్లయితే, మరొక ప్రోగ్రామ్ ఆ ఫైల్‌ను మార్చదు (లేదా తొలగించదు). ఈ సూత్రం ఫైల్‌లకు మాత్రమే పరిమితం కాదు, కానీ అవి చాలా సులభంగా అర్థమయ్యే ఉదాహరణను అందిస్తాయి.

ఆపరేటింగ్ సిస్టమ్ ఫంక్షన్‌లను (APIలు) కలిగి ఉంది, ఇది ప్రోగ్రామ్‌ను వనరులను పొందేందుకు మరియు/లేదా విడుదల చేయడానికి అనుమతిస్తుంది. ఒక వనరు బిజీగా ఉంటే, దానిని పొందిన ప్రోగ్రామ్ మాత్రమే దానితో పని చేయగలదు. వనరు ఉచితం అయితే, ఏదైనా ప్రోగ్రామ్ దానిని పొందవచ్చు.

మీ ఆఫీసు కాఫీ కప్పులను పంచుకున్నట్లు ఊహించుకోండి. ఎవరైనా కప్పు తీసుకుంటే, ఇతరులు దానిని తీసుకోలేరు. కానీ ఒకసారి కప్పును ఉపయోగించి, కడిగి, దాని స్థానంలో తిరిగి ఉంచినట్లయితే, ఎవరైనా దానిని మళ్లీ తీసుకోవచ్చు. బస్సు లేదా సబ్‌వేలో సీట్ల పరిస్థితి కూడా అలాగే ఉంటుంది. సీటు ఉచితం అయితే, ఎవరైనా దానిని తీసుకోవచ్చు. ఒక సీటు ఆక్రమించబడితే, అది తీసుకున్న వ్యక్తిచే నియంత్రించబడుతుంది.

బాహ్య వనరులను పొందడం .

మీ జావా ప్రోగ్రామ్ డిస్క్‌లోని ఫైల్‌తో పని చేయడం ప్రారంభించిన ప్రతిసారీ, జావా మెషీన్ దానికి ప్రత్యేక యాక్సెస్ కోసం ఆపరేటింగ్ సిస్టమ్‌ను అడుగుతుంది. వనరు ఉచితం అయితే, జావా యంత్రం దానిని పొందుతుంది.

కానీ మీరు ఫైల్‌తో పనిని పూర్తి చేసిన తర్వాత, ఈ వనరు (ఫైల్) తప్పనిసరిగా విడుదల చేయబడాలి, అంటే మీకు ఇకపై ఇది అవసరం లేదని మీరు ఆపరేటింగ్ సిస్టమ్‌కు తెలియజేయాలి. మీరు దీన్ని చేయకుంటే, మీ ప్రోగ్రామ్ ద్వారా వనరు కొనసాగుతుంది.

ఆపరేటింగ్ సిస్టమ్ ప్రతి రన్నింగ్ ప్రోగ్రామ్ ద్వారా ఆక్రమించబడిన వనరుల జాబితాను నిర్వహిస్తుంది. మీ ప్రోగ్రామ్ కేటాయించిన వనరుల పరిమితిని మించి ఉంటే, ఆపరేటింగ్ సిస్టమ్ మీకు కొత్త వనరులను అందించదు.

శుభవార్త ఏమిటంటే, మీ ప్రోగ్రామ్ ఆగిపోతే, అన్ని వనరులు స్వయంచాలకంగా విడుదల చేయబడతాయి (ఆపరేటింగ్ సిస్టమ్ దీన్ని చేస్తుంది).

చెడ్డ వార్త ఏమిటంటే, మీరు సర్వర్ అప్లికేషన్‌ను వ్రాస్తున్నట్లయితే (మరియు చాలా సర్వర్ అప్లికేషన్‌లు జావాలో వ్రాయబడ్డాయి), మీ సర్వర్ ఆగకుండా రోజులు, వారాలు మరియు నెలల పాటు అమలు చేయగలగాలి. మరియు మీరు రోజుకు 100 ఫైల్‌లను తెరిచి, వాటిని మూసివేయకపోతే, కొన్ని వారాలలో మీ అప్లికేషన్ దాని వనరుల పరిమితిని చేరుకుని క్రాష్ అవుతుంది. నెలరోజుల స్థిరమైన పనికి ఇది చాలా తక్కువగా ఉంది.

2. close()పద్ధతి

బాహ్య వనరులను ఉపయోగించే తరగతులు వాటిని విడుదల చేయడానికి ప్రత్యేక పద్ధతిని కలిగి ఉంటాయి: 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 అని వ్రాసాము. కొంచెం గజిబిజిగా ఉంది, మీరు అనుకోలేదా?

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తరగతికి పద్ధతి లేకపోతే -with-Resources స్టేట్‌మెంట్ ఎలా పని చేస్తుంది close()? సరే, ఏమీ పిలవబడదని అనుకుందాం. పద్ధతి లేదు, సమస్య లేదు.

కానీ tryతరగతికి అనేక close()పద్ధతులు ఉంటే -with-Resources స్టేట్‌మెంట్ ఎలా పని చేస్తుంది? మరియు వారికి పంపడానికి వాదనలు అవసరమా? మరియు తరగతికి పారామితులు లేకుండా పద్ధతి లేదా close()?

మీరు నిజంగా ఈ ప్రశ్నలను మీరే అడిగారని మరియు బహుశా ఇతరులు కూడా అడిగారని నేను ఆశిస్తున్నాను.

అటువంటి సమస్యలను నివారించడానికి, జావా సృష్టికర్తలు అనే ప్రత్యేక ఇంటర్‌ఫేస్‌తో ముందుకు వచ్చారు AutoCloseable, దీనికి ఒకే ఒక పద్ధతి ఉంది — close(), పారామీటర్‌లు లేవు.

-విత్-రిసోర్సెస్ స్టేట్‌మెంట్‌లో అమలు చేసే తరగతుల ఆబ్జెక్ట్‌లను మాత్రమేAutoCloseable వనరులుగా ప్రకటించవచ్చనే పరిమితిని కూడా వారు జోడించారు . tryఫలితంగా, అటువంటి వస్తువులు ఎల్లప్పుడూ close()పారామితులు లేని పద్ధతిని కలిగి ఉంటాయి.

మార్గం ద్వారా, పారామీటర్‌లు లేకుండా తరగతి దాని స్వంత పద్ధతిని కలిగి ఉన్న కానీ అమలు చేయని tryవస్తువును వనరుగా ప్రకటించడం -విత్-రిసోర్సెస్ స్టేట్‌మెంట్ సాధ్యమేనని మీరు భావిస్తున్నారా ?close()AutoCloseable

చెడ్డ వార్త: సరైన సమాధానం లేదు — తరగతులు తప్పనిసరిగా AutoCloseableఇంటర్‌ఫేస్‌ను అమలు చేయాలి.

శుభవార్త: జావాలో ఈ ఇంటర్‌ఫేస్‌ని అమలు చేసే అనేక తరగతులు ఉన్నాయి, కాబట్టి ప్రతిదీ తప్పనిసరిగా పని చేసే అవకాశం ఉంది.