Estou lendo um arquivo com estrutura abaixo, e depois o quebro em vários conjuntos de registros, onde terei threads para atuarem com estes conjuntos. Arquivo:
André da Silva Av. Pio XII, 334 055-21 36652012MCSP
Andrey dos Santos R. Pe. Manoel 112 055-21 36632112MSSP
Antonio Matos R.Mario da Cunha 456 055-21 33452212MCSP
A questão é que eu gostaria de trabalhar de uma forma dinâmica, pois através de números “mágicos” eu consigo resultados diferentes, e o meu objetivo é realizar as operações no menor tempo possível variando apenas a quantidade de threads ou quantidade de registros por thread, porem posso estar lendo um arquivo com 1milhão de registros ou 600 registros:
Aí é que eu pergunto: 1 -Tem como eu saber a quantidade de linhas (registros) do arquivo sem precisar lêr e contabilizar? 2 -Existe uma fórmula que me diga como balencear estes números?
resultados obtidos pelas variações de variáveis:
[size=9]1)registros= 30.000 - threads=10 - buffer=1000 - tempo= 29seg.
2)registros= 30.000 - threads=20 - buffer=1000 - tempo= 47seg.
5)registros= 250.000 - threads=20 - buffer=1500 - tempo= 15 minutos. ??? (para esta situação as 20 threads e os 1500 registros por thread não foram satisfatórios, pois pela lógica devera ser 5x maior que o exemplo 4[/size]
BufferedReader reader = new BufferedReader(new FileReader(arquivo));
while(reader.ready()){
//limita a quantidade de Threads
if(Thread.activeCount()<qtdeThreads) {
String[] registros = new String[buffer];
//faço um for para popular os registros[i] com as linhas do arquivo, limitado ao tamanho do buffer
}
//Instancio uma thread para processar a lista de registros
Thread thread = new Thread(new Processa(registros));
thread.start();
}
}
se o tamanho dos registros são fixos, você consegue saber de antemão o total deles, concorda?
basta dividir o tamanho do arquivo pelo tamanho do registro…
não tive tempo de pensar… mas deve ter alguma conta, sim… no entanto, se vc quiser uma SUPER exatidão, provavelmente a fórmula deverá levar em conta até os rpm’s do seu hd
se o tamanho dos registros são fixos, você consegue saber de antemão o total deles, concorda?
basta dividir o tamanho do arquivo pelo tamanho do registro…
não tive tempo de pensar… mas deve ter alguma conta, sim… no entanto, se vc quiser uma SUPER exatidão, provavelmente a fórmula deverá levar em conta até os rpm’s do seu hd
[]s
[/quote]
O problema é que o tamanho dos registros não é fixo, mas posso tentar recuperar antes da execução (se compensar a economia de tempo já podemos considerar um ponto de start :D), quanto ao hardware não me preocupo pq vai rodar em AIX.
Ficou grosseiro mas funciona, se alguém tiver alguma sugestão eu agradeço:
java.io.File f = new java.io.File(readPath);
java.io.InputStream is = new java.io.FileInputStream( f );
int tamanho = is.available();
BufferedReader reader1 = new BufferedReader(new FileReader(readPath));
if (reader1.ready()){
int tamanho_reg = reader1.readLine().length();
int qt_registros = tamanho/tamanho_reg;
System.out.println(qt_registros);
}
Amigo, a forma mais rápida de ler um arquivo seqüencial e texto é do começo para o fim.
De preferência, use um BufferedReader com um buffer bem grande (mais que os 8KB default), mas não grande demais (acho que 1MB costuma ser suficiente).
Olhe a documentação de java.io.BufferedReader para mais detalhes. (Dica: não é o construtor padrão que se usa)
Fazer isso que você quer fazer (jogar um monte de tranqueira na memória e ler fora de seqüência, usando um monte de threads) na verdade é contraproducente.
O correto é você usar as threads para processar os dados, não para ler as linhas.
[quote=thingol][quote]
5)registros= 250.000 - threads=20 - buffer=1500 - tempo= 15 minutos. ??? (para esta situação as 20 threads e os 1500 registros por thread não foram satisfatórios, pois pela lógica devera ser 5x maior que o exemplo 4
[/quote]
Isso ocorreu porque você carregou dados demais na memória e o computador começou a fazer “swap”. Quando isso ocorre o tempo gasto aumenta horrores.
[/quote]
Thingo,
Em questão de uso de memória neste modelo não deveria ser igual? Pois apenas o que muda é a quantidade de registros utilizados, mas a utilização de memória não seria a mesma devido a limitação de threads?
4)registros= 50.000 - threads=20 - buffer=1500 - tempo= 31seg.
5)registros= 250.000 - threads=20 - buffer=1500 - tempo= 15 minutos.
