Olá pessoal,
seguinte estou com uma dúvida e queria saber se alguém aqui já passou por isso segue o código da classe de teste abaixo,
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package testesocket;
import java.util.concurrent.PriorityBlockingQueue;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
*
* @author
*/
public class TesteFila {
private final int LIMIT = 500000;
private PriorityBlockingQueue<Integer> queue;
//private LinkedBlockingQueue<Integer> queue;
//private ArrayBlockingQueue<Integer> queue;
public static void main(String[] args) {
TesteFila testeFila = new TesteFila();
testeFila.start();
}
public void start(){
queue = new PriorityBlockingQueue<Integer>(LIMIT);
TH_Consumer tc = new TH_Consumer();
new Thread(tc).start();
test();
//tc.stop();
}
public class TH_Consumer implements Runnable{
private boolean running = true;
private long t;
private long total = 0;
public void run(){
try {
int count = 0;
long t = 0l;
while(count < LIMIT){
t = System.nanoTime();
queue.take();
total += (System.nanoTime() - t);
count++;
}
System.out.println("Total Take: " + count);
System.out.println("Total Tempo: " + total);
} catch (Exception ex) {
Logger.getLogger(TesteFila.class.getName()).log(Level.SEVERE, null, ex);
}
}
public void stop(){
this.running = false;
}
}
public void test(){
long t = 0l;
int i = 0;
long total = 0;
while(i < LIMIT){
t = System.nanoTime();
queue.add(i);
total += (System.nanoTime() - t);
i++;
}
System.out.println("total add: " + i);
System.out.println("total tempo: " + total);
}
}
Qual o problema?
O problema é o seguinte, ao medir o tempo que leva o add na fila e o take da fila percebi, diferentemente do que eu pensava, que o take leva mais tempo do que o add e no meu cenário atual de uma média de 51 mensagens por milliseconds as mensagens acumulam, me gerando problemas.
o teste foi realizando entre as seguintes filas
PriorityBlockingQueue<Integer>
LinkedBlockingQueue<Integer>
ArrayBlockingQueue<Integer>
e todas ficaram com o tempo de add menor que o tempo do take, seja ele o tempo total ou o tempo isolado para cada mensagem.
Concordo que a métrica de tempo não é adequada, porém, ao executar o mesmo teste em uma fila bloqueante no C# o cenário é diferente, tenho um take mais rápido que o add.
alguém poderia me explicar o que acontece e se isso é real, alguém já passou por este problema? e como resolveu?
desde já, grato pela ajuda.
