ජාවා වැඩසටහන් තුල Buffered Stream යොදාගන්නා අයුරු

මීට පෙර පාඩම් වලදී අපි Stream පිලිබඳ කතාකලානෙ අපි මෙම පාඩමෙන් තවත් වැදගත් Stream වර්ගයක් වන Buffered Stream පිලිබඳ අධ්‍යයනය කරමු. 

අපි මීට පෙර සලකා බලන ලද FileInputStream , FileReader යන Stream වර්ග සැලකූ විට කෙලින්ම ඒවා යොදාගෙන කිසියම් resource එකක් භාවිතා කිරීමේදී ඒවායෙන් ලබාදෙන සෑම  read, write request එකක් සඳහාම අදාල resource එක access කිරීම සිදුවනවා. උදාහරණයක් ලෙසට අපි හිතමු  අපිට access කිරීමට අවශ්‍ය resource එක disk file එකක් කියල. එහිදී සෑම read, write request එකකදීම hard disk එකේ අදාල file එක access කිරීම සිදුවනවා. මෙහිදී JVM (Java Virtual Machine) එක විසින් native calls(operating system එකට අදාල low level methods) භාවිතා කිරීම සිදුකෙරෙනවා. එනම් සෑම read, write request එකකටම native calls invoke කිරීමට සිදුවනවා.  තවත් උදාහරණයක් ලෙස අපි සලකමු මෙම resource එක client Socket එකක් කියල. එවිට ඉහත ආකාරයේ buffered නොවන Stream එකක් යොදාගත්තොත් සෑම read, write request එකක් සඳහාම network resources භාවිතාවීම සිදුවනවා. කාර්‍යක්ෂමතාව අතින් සැලකීමේදී මෙය හොඳ විසඳුමක් වන්නේ නැහැ.

අපි දැන් Buffered Stream එකකදී සිදුවන ක්‍රියාවලිය කුමක්දැයි සලකා බලමු, Buffered Stream එකකදී read, write යනාදිය සිදුකරනුයේ සෘජුව අදාල resource එක සම්බන්දවී නොවේ "buffer" නම් memory area එකකිනි. මේ සඳහා "buffer" යනුවෙන් හැඳින්වෙන ප්‍රදේශයක් ප්‍රධාන මතකයේ (main memory/RAM) වෙන්ව පවතී. buffer එක හිස්වූ විට පමණක් OS එකට අදාල low level methods invoke වීම සිදුවී "buffer" එක පිරේ(read කරන විටදී). RAM එක සම්බන්ද I/O operations දෘඩ තැටිය සම්බන්ද  I/O operations වලට වඩා ඉතා වේගවත් නිසා Buffered stream යොදාගෙන I/O operations සිදුකිරීමේදී උපරිම කාර්‍යක්ෂමතාවයක් ලබාගත හැකිය. දැන් ඔබට වැටහෙනවා ඇති Buffered Stream භාවිතයේදී ඉහත සඳහන් කල Buffered නොවන stream වලදී ඇතිවන ගැටලුවට සාර්ථක විසඳුමක් ලැබී තිබෙන ආකාරය.

Buffered Stream එකක් සකසාගන්නේ කොහොමද?

මෙහිදී සිදුකරන්නේ non buffered stream object එකක් buffered stream object එකක් මගින් wrap කිරීමයි. පහත දැක්වෙන පරිදි මෙය සිදුකල හැකිය.

Syntax 01

//for input operations
FileReader fileRdr=new FileReader("myFile.txt");
BufferedReader buffRdr=new BufferedReader(fileRdr);

//for output operations
FileWriter fileWrtr=new FileWriter("myFile2.txt");
BufferedWriter buffWrtr=new BufferedWriter(fileWrtr);

Syntax 02 (ඉහත ක්‍රියාවලියම කෙටියෙන්)

//for input operations
BufferedReader buffRdr=new BufferedReader(new FileReader("myFile.txt"));

//for output operations
BufferedWriter buffWrtr=new BufferedWriter(new FileWriter("myFile2.txt"));

ඉහත උදාහරණ වලින් පෙන්වා ඇත්තේ character stream handle කිරීම සඳහා buffered stream යොදාගන්නා ආකාරයයි. Byte streams සඳහා BufferedInputStream සහ BufferedOutputStream යොදාගත හැකිය. 

Buffered stream එකක buffer size එක ලබාදෙන්නේ කොහොමද?
අපි ඉහත දක්වා ඇති උදාහරණ වලදී buffer size එකක් ලබාදී නොමැත constructor එකෙහි ලබාදී ඇත්තේ wrap කිරීමට stream object එක පමණි. එවිට JVM එක විසින් කිසියම් default අගයක් buffer size එක ලෙස තෝරා ගනී. මෙම අගය රඳාපවතිනුයේ OS එක, system configuration එක, Main memory ධාරිතාවය වැනි සාධක මතය. නමුත් අපට buffer size එක අපේ අභිමතය පරිදි ලබාදිය යුතු නම් buffered input සහ buffered output යන stream දෙවර්ගයටම buffer size ලබාදිය හැකිය. පහත දැක්වෙන අන්දමට එය සිදුකල හැකිය.
Syntax 03

BufferedReader bfrRdr=new BufferedReader(new FileReader("myFile.txt",512*1024);
BufferedWriter bfrRdr=new BufferedWriter(new FileWriter("myFile2.txt",512*1024);

ඉහත උදාහරණයේදී Buffer size එක ලෙස 512KB ප්‍රමාණයක් ලබාදී ඇත මෙම අගය bytes වලින් ලබාදිය යුතු නිසා (512*1024) ලෙස ලබාදී ඇත.

Buffered Stream එකක් flush කිරීම යනු කුමක්ද?

 ඇතැම් වැදගත් අවස්ථා වලදී buffer එකේ ඇති තොරතුරු resource එකට ලිවීමට සිදුවන අවස්ථා පැමිණේ. මෙවැනි අවස්ථාවකදී flush නම් ක්‍රියාවලිය සිදුකරයි. මේ සඳහා flush() නම් විධානය භාවිතා කරයි. 
Non buffered stream සඳහාද flush() method එක පවතී. නමුත් ඒවායේදී flush() කිරීම මගින් කිසිම  ප්‍රතිඵලයක් නොමැත. එයට හේතුව ඔබට මේ වනවිට සිතාගත හැක. Non buffered stream වලදී flush කිරීමට memory area එකක් නොමැති වීම මීට හේතුවයි.

Java 1.6 Documentation එකෙහි දැක්වෙන පරිදි Buffered Stream සඳහා අදාල වන constructors සහ methods පහත දක්වා ඇත.

---

Class BufferedInputStream

Constructor Summary
BufferedInputStream(InputStream in)           Creates a BufferedInputStream and saves its argument, the input stream in, for later use.
BufferedInputStream(InputStream in, int size)           Creates a BufferedInputStream with the specified buffer size, and saves its argument, the input stream in, for later use.

Method Summary
int	available()           Returns an estimate of the number of bytes that can be read (or skipped over) from this input stream without blocking by the next invocation of a method for this input stream.
void	close()           Closes this input stream and releases any system resources associated with the stream.
void	mark(int readlimit)           See the general contract of the mark method of InputStream.
boolean	markSupported()           Tests if this input stream supports the mark and reset methods.
int	read()           See the general contract of the read method of InputStream.
int	read(byte[] b, int off, int len)           Reads bytes from this byte-input stream into the specified byte array, starting at the given offset.
void	reset()           See the general contract of the reset method of InputStream.
long	skip(long n)           See the general contract of the skip method of InputStream.

Class BufferedOutputStream

Constructor Summary
BufferedOutputStream(OutputStream out)           Creates a new buffered output stream to write data to the specified underlying output stream.
BufferedOutputStream(OutputStream out, int size)           Creates a new buffered output stream to write data to the specified underlying output stream with the specified buffer size.

Method Summary
void	flush()           Flushes this buffered output stream.
void	write(byte[] b, int off, int len)           Writes len bytes from the specified byte array starting at offset off to this buffered output stream.
void	write(int b)           Writes the specified byte to this buffered output stream.

 

ඉහත දැක්වෙන methods භාවිතාකරන අන්දම හොඳින් වටහාගැනීමෙන් වඩාත් කාර්‍යක්ශම වැඩසටහන් ලිවිය හැකිය. 

අපි මීලඟ පාඩමෙන් Buffered Stream යොදාගෙන ප්‍රායෝගික ජාවා වැඩසටහනක් ලියන අන්දම බලමු.