Différence entre les extraits suivants. Comment mon flux d'entrée a-t-il lu les cycles a été réduit?

Question

J'ai mon flux d'entrée étendue qui est comme

PREMIER TRAIL

public class DataReadInputStream extends java.io.InputStream{ 

private InputStream in = null; 
public DataReadInputStream(boolean decompress) { 
initInputStream(); 
} 
//Contains other read methods from which are in InputStream 

public int read(byte[] arr, int offset, int length) { 
return this.in.read(arr, offset, length); 
} 

public void initInputStream(boolean decompress) { 
//this.in contains some input stream value 
this.in = decompress ? new GZIPInputStream(this.in) : this.in; 
// NOTE: GZIPInputStream reads only 512 bytes at a time since the default buffer size in GZIPInputStream is 512 
} 

} 

maintenant lors de la lecture d'un contenu de fichier avec mon DataReadInputStream enveloppé dans les BufferedInputStream comme ce qui suit

ins = new DataReadInputStream(true); 
bis = new BufferedInputStream(ins); 
servletOutStream = res.getOutputStream(); 

int c = 0; 
int len = 4096; 
byte bufr[] = new byte[len]; 
while ((c = bis.read(bufr, 0, len)) != -1) { 
    servletOutStream.write(bufr, 0, c); 
} 

Note: J'emballe mon DataReadInputStream au sein de BufferedInputStream pour réduire le nombre d'appels de lecture (par exemple, BufferedInputStream f maux le tampon jusqu'à ce qu'il peut contenir - ce qui réduit le nombre d'appels système), mais il ne lit que 512 octets à la fois - ici je ne pouvais voir aucune raison d'envelopper mon DataReadInputStream dans les BufferedInputStream

ESSAI DEUXIÈME

Je suis en train de réaliser le même comme,

public class DataReadInputStream extends java.io.InputStream{ 

public BufferedInputStream in = null; 
public DataReadInputStream(boolean decompress) { 
initInputStream(); 
} 
//Contains other read methods from which are in InputStream 

public int read(byte[] arr, int offset, int length) { 
return this.in.read(arr, offset, length); 
} 

public void initInputStream(boolean decompress) { 
InputStream ins = decompress ? new GZIPInputStream(this.in) : this.in; 
this.in = new BufferedInputStream(ins); 
} 

} 

maintenant, quand j'essaie de lire le contenu du fichier avec ce DataReadInputStream je pouvais lire 4096 octets à la fois soit à la fois i) et ii) (que j'ai donné comme ma taille de tampon ici)

i)

ins = new DataReadInputStream(true); 
bis = new BufferedInputStream(ins); 
servletOutStream = res.getOutputStream(); 

int c = 0; 
int len = 4096; 
byte bufr[] = new byte[len]; 
while ((c = bis.read(bufr, 0, len)) != -1) { 
    servletOutStream.write(bufr, 0, c); 
} 

ii)

ins = new DataReadInputStream(true); 
servletOutStream = res.getOutputStream(); 

int c = 0; 
int len = 4096; 
byte bufr[] = new byte[len]; 
while ((c = ins.read(bufr, 0, len)) != -1) { 
    servletOutStream.write(bufr, 0, c); 
}  

Avec DEUXIÈME ESSAI le nombre de cycles de lecture réduit obtenu ce qui améliore considérablement la vitesse de téléchargement fichier comment?

Tout conseil à cet égard est grandement apprécié! Merci :-)

Answer 1

Votre première approche utilise un BufferedInputStream alors intentionnellement vainc la mise en mémoire tampon en utilisant la mise en mémoire tampon personnalisée et un appel read de bas niveau. Ainsi vous avez tous les frais généraux et aucun de l'avantage.