Java Help file download

[MihiCherub]

මචන්ල මට මේ කෝඩ් එකේ byte array සයිස් එක ගැන පොඩ්ඩක් පැහැදිලි කරපන්කො.. මේ array සයිස් එකෙන් මොකද්ද වෙන්නෙ. මේක මීට වඩා වැඩි කලොත් මොකද වෙන්නෙ?

කෝඩ් එක file එකක් download කරගන්න එකක්.

 byte[] buf = new byte[1024];
  int bytesRead;
  while ((bytesRead = is.read(buf)) != -1) {
     fos.write(buf, 0, bytesRead);
  }

download එකේ ස්පීඩ් එකට මේ array size එක බලපානවද?
​

 

[MihiCherub]

bump

thx 10+

 

[Radioactive]

ඔතනින් කියන්නේ මචන් variable එකේ size එක. දැන් ඔතන තියෙන්නේ byte variable එකක් නේ? එතකොට ඔතන memory එකේ හදනවා byte blocks 1024 ක්, ඊට පස්සේ ඒක variable එකකට assign කරනවා, ඊට පස්සේ අපිට ඒ variable එක use කරන්න පුලුවන් අපේ අනෙක් data assign කරගන්න. ලොකු කරාට ප්‍රශ්ණයක් නෑ.

 

[Rovin]

bmp

 

[DjSpK]

 byte[] buf = new byte[1024];

Fixed Size Byte Array එකක්. මෙකෙන් කරන්නේ කොච්චර Bytes ප්‍රමාණයක් එක වරකට Response Stream එකෙන් Read කරනවද කියන එක. එත් 1024 Bytes ප්‍රමාණය එක පාරම ගන්න බැරිනම් (Slow Connection) . ඊට අඩු Bytes ප්‍රමාණයක් Read කරණවා.

 int bytesRead;

මෙතනදි දැනට කොපමණ Bytes ප්‍රමානයක් Read කරාද කියලා Store කරගන්නවා. කලින් කිව්වා වාගේ 1024 Bytes Buffer කරගන්න බැරිවුනොත්. පුළුවන් ප්‍රමානය ගන්නවා එ ගත්ත ප්‍රමාණය ඔය Variable එකේ Store වෙනවා.

while ((bytesRead = is.read(buf)) != -1) {

මෙතනදි EOF(End OF File) වෙනකන් Response Stream එක Read කරණවා. BytesRead = -1 වෙනවා කියන්නේ File එක Read වෙලා ඉවරයි.

 fos.write(buf, 0, bytesRead);

Fso කියන Steam එකට ගත්ත Bytes ප්‍රමාණය Write කරණවා.
Eg:

byte[] buf = new byte[1024];

buf = {90,60,45,20}; Read 4 Bytes
bytesread = 4
fso.write(buf(90,60,45,20),0,bytesread(size of current buffer =4))

 

[DjSpK]

ඔතනින් කියන්නේ මචන් variable එකේ size එක. දැන් ඔතන තියෙන්නේ byte variable එකක් නේ? එතකොට ඔතන memory එකේ හදනවා byte blocks 1024 ක්, ඊට පස්සේ ඒක variable එකකට assign කරනවා, ඊට පස්සේ අපිට ඒ variable එක use කරන්න පුලුවන් අපේ අනෙක් data assign කරගන්න. ලොකු කරාට ප්‍රශ්ණයක් නෑ.

ලොකු කරාට ප්‍රශ්ණයක් නෑ.

ලොකු කරොත් නම් ප්‍රශ්ණයක් ඇතිවෙන්න තියෙන ඉඩ කඩ වැඩී. 1024 Bytes ප්‍රමාණයක් එක සැරයකට Buffer කරන්න ඔන Connection එකකට පුළුවන්. වැඩි වෙලා Connection එකට Read කරගන්න බැරිවුනොත්. Timeout Exception එකක් Throw වෙනවා.

 

[Radioactive]

ලොකු කරොත් නම් ප්‍රශ්ණයක් ඇතිවෙන්න තියෙන ඉඩ කඩ වැඩී. 1024 Bytes ප්‍රමාණයක් එක සැරයකට Buffer කරන්න ඔන Connection එකකට පුළුවන්. වැඩි වෙලා Connection එකට Read කරගන්න බැරිවුනොත්. Timeout Exception එකක් Throw වෙනවා.

time out exception එක මම දන්න විදියට එන්නේ, process/operation එකකට allocated කරලා තියෙන කාලය expire වුනාමයි නැතුව buffer size එක වැඩි වුනාම නෙවෙයි. buffer size එක ඕන තරම් දැම්මට ලොකු ප්‍රශ්නයක් නෑ. මම ඕක 4MB වෙනකම් හිටන් ගිහින් තියෙනවා. මම ඒකෙන් අදහස් කරන්නේ නෑ 1GB වගේ යන්න කියලා, මම එච්චර ගිහිනුත් නෑ.

 

[AloneGuy90]

time out exception එක මම දන්න විදියට එන්නේ, process/operation එකකට allocated කරලා තියෙන කාලය expire වුනාමයි නැතුව buffer size එක වැඩි වුනාම නෙවෙයි. buffer size එක ඕන තරම් දැම්මට ලොකු ප්‍රශ්නයක් නෑ. මම ඕක 4MB වෙනකම් හිටන් ගිහින් තියෙනවා. මම ඒකෙන් අදහස් කරන්නේ නෑ 1GB වගේ යන්න කියලා, මම එච්චර ගිහිනුත් නෑ.

ඇහ්වට මුකුත් හිතන්න එපා මචං. සීරියස් අහන්නේ ඇත්තටම උබ මොනවද බන් කරන්නේ? උබ බන් නොදන්න මුගුලක්නෑනේ? උබ ජොබ් එකට කරන්නේ මොකකද් බන්?

 

[MihiCherub]

 byte[] buf = new byte[1024];

Fixed Size Byte Array එකක්. මෙකෙන් කරන්නේ කොච්චර Bytes ප්‍රමාණයක් එක වරකට Response Stream එකෙන් Read කරනවද කියන එක. එත් 1024 Bytes ප්‍රමාණය එක පාරම ගන්න බැරිනම් (Slow Connection) . ඊට අඩු Bytes ප්‍රමාණයක් Read කරණවා.

 int bytesRead;

මෙතනදි දැනට කොපමණ Bytes ප්‍රමානයක් Read කරාද කියලා Store කරගන්නවා. කලින් කිව්වා වාගේ 1024 Bytes Buffer කරගන්න බැරිවුනොත්. පුළුවන් ප්‍රමානය ගන්නවා එ ගත්ත ප්‍රමාණය ඔය Variable එකේ Store වෙනවා.

while ((bytesRead = is.read(buf)) != -1) {

මෙතනදි EOF(End OF File) වෙනකන් Response Stream එක Read කරණවා. BytesRead = -1 වෙනවා කියන්නේ File එක Read වෙලා ඉවරයි.

 fos.write(buf, 0, bytesRead);

Fso කියන Steam එකට ගත්ත Bytes ප්‍රමාණය Write කරණවා.
Eg:

byte[] buf = new byte[1024];

buf = {90,60,45,20}; Read 4 Bytes
bytesread = 4
fso.write(buf(90,60,45,20),0,bytesread(size of current buffer =4))

පට්ට මේක තමා මට ඕන උන උත්තරෙ. 10+ නියෙමෙට තියෙනව.. හැබැයි වැඩේ තියෙන්නෙ මගේ 8mbps එකෙන් 3mb file එකක් dowload වෙන්න මේ ක්‍රමෙන් 2min කටත් වඩා යනවනෙ..

BUILD SUCCESSFUL (total time: 1 minute 52 seconds)

නිකන් browser එකෙන් මේක download කලොත් තත් 10ක් වත් යන්නෙ නෑ. කොහොමද ඒක හදා ගන්නෙ.

 

[DjSpK]

time out exception එක මම දන්න විදියට එන්නේ, process/operation එකකට allocated කරලා තියෙන කාලය expire වුනාමයි නැතුව buffer size එක වැඩි වුනාම නෙවෙයි. buffer size එක ඕන තරම් දැම්මට ලොකු ප්‍රශ්නයක් නෑ. මම ඕක 4MB වෙනකම් හිටන් ගිහින් තියෙනවා. මම ඒකෙන් අදහස් කරන්නේ නෑ 1GB වගේ යන්න කියලා, මම එච්චර ගිහිනුත් නෑ.

buffer එක 4MB දාන එක ප්‍රශ්ණයක් නැහැ එත් Slow Connection එකකදි 4MB Buffer එකකට යන්න බැරි වුනොත් Default Timeout Exception එකක් Throw වෙන්න තියන ඉඩ වැඩි. Timeout එක හදන්න පුළුවන් ඔන කාලයක් දිලා. එත් හොදම දේ buffer එකට අඩු Bytes ප්‍රමාණයක් දෙන එක.Best = (1024 Bytes) to (2048 Bytes)

 

[DjSpK]

පට්ට මේක තමා මට ඕන උන උත්තරෙ. 10+ නියෙමෙට තියෙනව.. හැබැයි වැඩේ තියෙන්නෙ මගේ 8mbps එකෙන් 3mb file එකක් dowload වෙන්න මේ ක්‍රමෙන් 2min කටත් වඩා යනවනෙ..
BUILD SUCCESSFUL (total time: 1 minute 52 seconds)
නිකන් browser එකෙන් මේක download කලොත් තත් 10ක් වත් යන්නෙ නෑ. කොහොමද ඒක හදා ගන්නෙ.

Radioactive කියලා තියෙන විදිහට Buffer Array Size එක වැඩි කරලා බලන්න.

 

[MihiCherub]

Radioactive කියලා තියෙන විදිහට Buffer Array Size එක වැඩි කරලා බලන්න.

BUILD SUCCESSFUL (total time: 2 minutes 1 second)

වැඩක් නෑ වැඩි කලාම මෙහෙමයි..

 

[Radioactive]

buffer එක 4MB දාන එක ප්‍රශ්ණයක් නැහැ එත් Slow Connection එකකදි 4MB Buffer එකකට යන්න බැරි වුනොත් Default Timeout Exception එකක් Throw වෙන්න තියන ඉඩ වැඩි. Timeout එක හදන්න පුළුවන් ඔන කාලයක් දිලා. එත් හොදම දේ buffer එකට අඩු Bytes ප්‍රමාණයක් දෙන එක.Best = (1024 Bytes) to (2048 Bytes)

ඒක හරි නමුත් connection එක තවත් slow වුනොත් එතකොටත් timeout exception එක එනවා. එතකොට මෙතන ප්‍රශ්නය time out එක නෙවෙයි ,connection එකේ speed එකයි. අපි කොහෙන් හරි data read කරලා, ඒක array එකකට දානවා කියල හිතන්න, ඊට පස්සේ ඒ operation එක ඉවර වෙනකම් OS එක බලාගෙන ඉන්නවා ,බලාගෙන ඉදලා ඒක නියමිත කාලය තුළදි ඉවර වුනේ නැත්නම් time out exception එක එනවා, අපිට ඒකට වැඩි කාලයක් දෙන්න පුලුවන් ඔය කිව්වා වගේ නමුත් මෙතන ප්‍රශ්ණය timeout එක නෙවෙයි, ප්‍රශ්නය connection speed එක. array වලින් data read කරන එක device එකකදි වෙන්න පුලුවන්, network එකකදි වෙන්න පුලුවන්, file system එකකදි වෙන්න පුලුවන් (hard disk එකකදි වගේ) ,network එකකදි නම් මේක රදාපවතින්නේ network එකේ speed එක මතයි, device එකකදීත් එහෙමයි නමුත් hard disk එකේ නම් වේගයෙන් data transfer කරන්න පුලුවන් එතකොට time out exception එක ඒමේ සම්භාවිතාව අඩුයි. අනික ලොකු buffer size එකක් දැම්මම තියෙන වාසිය තමයි එතකොට device එක busy වෙන්නේ නෑ සැරෙන් සැරෙන්. hard disk එකකදි නම් buffer size එක small නම් එතකොට application එක constant hard disk එකට access වෙනකොට ඒක hard disk එකට හොද නෑ ඉතින් එකපාර ලොකු ප්‍රමාණයක් read කරලා අරගෙන array එකට දාලා, ඒක අදාළ තැනට flush කරන්න පුලුවන්.

 

[DJvodka]

post your full source code

 

[DjSpK]

BUILD SUCCESSFUL (total time: 2 minutes 1 second)

වැඩක් නෑ වැඩි කලාම මෙහෙමයි..

Size එක 4MB(1024*4096) වගේ දිලා බලන්න එත් එහෙම වෙන අවුලක් තියෙන්නේ .
එත් අවුල් ගියොත් Full Code එක දාන්න.

 

[DjSpK]

ඒක හරි නමුත් connection එක තවත් slow වුනොත් එතකොටත් timeout exception එක එනවා. එතකොට මෙතන ප්‍රශ්නය time out එක නෙවෙයි ,connection එකේ speed එකයි. අපි කොහෙන් හරි data read කරලා, ඒක array එකකට දානවා කියල හිතන්න, ඊට පස්සේ ඒ operation එක ඉවර වෙනකම් OS එක බලාගෙන ඉන්නවා ,බලාගෙන ඉදලා ඒක නියමිත කාලය තුළදි ඉවර වුනේ නැත්නම් time out exception එක එනවා, අපිට ඒකට වැඩි කාලයක් දෙන්න පුලුවන් ඔය කිව්වා වගේ නමුත් මෙතන ප්‍රශ්ණය timeout එක නෙවෙයි, ප්‍රශ්නය connection speed එක. array වලින් data read කරන එක device එකකදි වෙන්න පුලුවන්, network එකකදි වෙන්න පුලුවන්, file system එකකදි වෙන්න පුලුවන් (hard disk එකකදි වගේ) ,network එකකදි නම් මේක රදාපවතින්නේ network එකේ speed එක මතයි, device එකකදීත් එහෙමයි නමුත් hard disk එකේ නම් වේගයෙන් data transfer කරන්න පුලුවන් එතකොට time out exception එක ඒමේ සම්භාවිතාව අඩුයි. අනික ලොකු buffer size එකක් දැම්මම තියෙන වාසිය තමයි එතකොට device එක busy වෙන්නේ නෑ සැරෙන් සැරෙන්. hard disk එකකදි නම් buffer size එක small නම් එතකොට application එක constant hard disk එකට access වෙනකොට ඒක hard disk එකට හොද නෑ ඉතින් එකපාර ලොකු ප්‍රමාණයක් read කරලා අරගෙන array එකට දාලා, ඒක අදාළ තැනට flush කරන්න පුලුවන්.

එකගයි.. එත් මගේ අත්දැකිම් අනුවනම SLT FUP වැටුනම කලින් Code කරපු Download Classes Re Code කරන්න උනා Download Speed එකට ගැලපෙන විදිහට. Performace වලට බලපානවා.

Basically, you want a buffer large enough so you are not needlessly reading data from the stream, but not so large you diminish returns. If your buffer is too big (~MBs), then you will increase your memory cache misses, which might actually start to decrease your performance. Of course, this varies a lot based on actual H/W (bus speed, cache size, etc), but I've seem cases where a 4MB buffer was slower than the 4KB buffer (both cases had long lifetimes, so GC was not an issue).

 

[MihiCherub]

post your full source code

Size එක 4MB(1024*4096) වගේ දිලා බලන්න එත් එහෙම වෙන අවුලක් තියෙන්නේ .
එත් අවුල් ගියොත් Full Code එක දාන්න.

මේ 1MB දාල. Full code එක කියල එකක් නෑ. ඕක විතරයි නෙ තියෙන්නෙ..

1MB දාල 1024*1024
BUILD SUCCESSFUL (total time: 1 minute 31 seconds)

4MB දාල 1024*4096
BUILD SUCCESSFUL (total time: 1 minute 38 seconds)

                            try (FileOutputStream fos = new FileOutputStream(file)) {
                                byte[] buf = new byte[1024*4096];
                                int bytesRead;
                                while ((bytesRead = is.read(buf)) != -1) {
                                    fos.write(buf, 0, bytesRead);
                                }
                            }

 

[DJvodka]

මේ 1MB දාල. Full code එක කියල එකක් නෑ. ඕක විතරයි නෙ තියෙන්නෙ..

1MB දාල 1024*1024
BUILD SUCCESSFUL (total time: 1 minute 31 seconds)

4MB දාල 1024*4096
BUILD SUCCESSFUL (total time: 1 minute 38 seconds)

                            try (FileOutputStream fos = new FileOutputStream(file)) {
                                byte[] buf = new byte[1024*4096];
                                int bytesRead;
                                while ((bytesRead = is.read(buf)) != -1) {
                                    fos.write(buf, 0, bytesRead);
                                }
                            }

ඕක buffer එකේ අවුලක් නෙවෙයි. උබ stream එක රීඩ් කරන්නෙ බයිට් එකෙන් බයිට් එක නැතුව බ්ලොක් ලෙවල් එකෙන් නෙවෙයි. එක්කො inputstream එක BufferedInputStream එකක wrap කරල රීඩ් කර ගනින් නැත්තම් read(byte[], int, int) එක යූස් කරපං

 

[DjSpK]

මේ 1MB දාල. Full code එක කියල එකක් නෑ. ඕක විතරයි නෙ තියෙන්නෙ..

1MB දාල 1024*1024
BUILD SUCCESSFUL (total time: 1 minute 31 seconds)

4MB දාල 1024*4096
BUILD SUCCESSFUL (total time: 1 minute 38 seconds)

                            try (FileOutputStream fos = new FileOutputStream(file)) {
                                byte[] buf = new byte[1024*4096];
                                int bytesRead;
                                while ((bytesRead = is.read(buf)) != -1) {
                                    fos.write(buf, 0, bytesRead);
                                }
                            }

Try above solution

 

[Radioactive]

එකගයි.. එත් මගේ අත්දැකිම් අනුවනම SLT FUP වැටුනම කලින් Code කරපු Download Classes Re Code කරන්න උනා Download Speed එකට ගැලපෙන විදිහට. Performace වලට බලපානවා.

SLT FUP system එක අනුව, ඒ ගොල්ලෝ කරන්නේ connection එක throttle කරන එකයි ,එතකොට packets ගොඩක් නැති වෙනවා , එතකොට ඔතන ප්‍රශ්ණය තියෙන්නේ connection throttle වෙන එකේයි. ඒක ඉතින් SLT FUP system ඒකේ ප්‍රශ්ණයක්.
TCP/IP protocol වලදි නම් මේක හදාගන්න පුලුවන් මොකද ඒ protocol එකේ specification එක අනුව transfer වෙච්ච data verify කරනවා නමුත් UDP protocol ඒකේ නම් බෑ. නමුත් මම දැකලා තියෙනවා TCP/IP එක හරහා ආපු data පවා lose වෙන හැටි.

ඕකේ කියලා තියෙන විදියට memory cache misses වෙන එකේ සම්භාවිතාව අඩුයි ,එහෙම වෙන්නේ memory එකේ fault එකක් නම් හෝ CPU/Motherboard compatibility වුනේ නැත්නම් විතරයි . CPU to memory transferring වෙන විදිය ගත්තම. system memory එකේ data store වෙනවා යම් කිසි address එකක, ඊට පස්සේ CPU එකෙන් address bus line එක දිගේ address එක යවලා ඒකේ තියෙන data ,data bus line එක දිගේ ram එකෙන් ලබාගන්නවා, මේක හරියට අපි කොහේ හරි ගෙයකට ලියුමක් දාලා ඒ ගෙදරින් මොනවා හරි ගෙන්වා ගන්නවා වගේ, අපි එහෙම ලියුමක් දාන්න ඒ ගෙදර address එක දැනගන්න ඕන නේ. ඊට පස්සේ ඒක process කරලා ආයි ram එකටම data එක release කරනවා. අළුත් processors වල තියෙනවා L2 cache කියලා එකක්, ඒකෙන් කරන්නේ ram එකෙන් ගන්න data එකේ තාවකාලික ලෙස ගබඩා කරගන්න එකයි, ඊට පස්සේ මේක l1 cache එකට යනවා, එතනින් process වෙන්න යනවා. ඉතින් අපි buffer size එක කොච්චර දැම්මත් ප්‍රශ්ණෑයක් නෑ ,මොකද අන්තිමට CPU එකේ buffer limit එකක් තියෙනවා. අනික CPU වල වුනත් බලන්න, cache memory එක වැඩියි කියන්නේ CPU එක හොදයි performance එක වැඩියි.

නමුත් network එකකදි නම් fast response තියෙන්න ඕන නේ එතකොට buffer size එක අඩු නම් හොදයි,මේක වැඩි නම් buffer එක flush වෙනකම් ඉන්න ඕනේ response එක ලබාගන්න එතකොට වෙලාව යනවා. dvd එකකට data write කරනකොට වගේ නම් buffer size එක වැඩි නම් හොදයි එතකොට data misses විමේ සම්භාවිතාව අඩුයි මොකද ram එකේ speed එක වැඩියි hard disk එකට වඩා, hard disk එකෙන් slow එකේ data read කරගෙන ගියොත් dvd එක write වෙන වේගෙට ඒ data write කරන්න බෑ එතකොට data misses වෙනවා. ඉතින් මම හිතන්නේ scenario එක අනුව තමයි buffer size එක තීරණය කරන්න වෙන්නේ.