Dúvida com Leitura de arquivo e execução de threads

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.

3)registros= 50.000 - threads=10 - buffer=1000 - tempo= 43seg.
4)registros= 50.000 - threads=20 - buffer=1500 - tempo= 31seg.

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();
                }
        }

kosak,

  1. 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…

  2. 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 :slight_smile:

[]s

[quote=ramonchiara]kosak,

  1. 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…

  2. 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 :slight_smile:

[]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.

vlw

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); }

Cara esse teu código só irá funcionar se as linhas possuirem a mesma quantidade de caracters.

RandomAccessFile random = new RandomAccessFile("arquivo.txt", "rw");         
long tamanho = random.length()/random.readLine().length();

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.

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=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.