problème Java performance avec LinkedBlockingQueue

Question

c'est mon premier post sur stackoverflow ... J'espère que quelqu'un peut me aider

J'ai une grande régression de performances avec Java 6 LinkedBlockingQueue. Dans le premier fil, je génère des objets que je pousse dans la file d'attente Dans le second fil je tire ces objets. La régression des performances se produit lorsque la méthode take() du LinkedBlockingQueue est appelée fréquemment. J'ai surveillé l'ensemble du programme et la méthode take() a réclamé le plus de temps global. Et le débit passe de ~ 58MB/s à 0,9 Mo/s ...

la pop file d'attente et les méthodes prendre ar appelé avec une méthode statique de cette classe

public class C_myMessageQueue { 

    private static final LinkedBlockingQueue<C_myMessageObject> x_queue = new LinkedBlockingQueue<C_myMessageObject>(50000); 

    /** 
    * @param message 
    * @throws InterruptedException 
    * @throws NullPointerException 
    */ 
    public static void addMyMessage(C_myMessageObject message) 
      throws InterruptedException, NullPointerException { 
     x_queue.put(message); 
    } 

    /** 
    * @return Die erste message der MesseageQueue 
    * @throws InterruptedException 
    */ 
    public static C_myMessageObject getMyMessage() throws InterruptedException { 
     return x_queue.take(); 
    } 
} 

comment puis-je régler la take() méthode pour accomplir au moins 25Mb/s, ou est-il une autre classe que je peux utiliser qui bloquera lorsque la "file d'attente" est pleine ou vide.

Sincères salutations

Bart

P.S .: désolé pour mon mauvais anglais, je suis de l'Allemagne;)

Answer 1

Votre thread producteur simplement met plus d'éléments que le consommateur consomme, de sorte que la file d'attente atteint finalement sa limite de capacité, donc le producteur attend.

La consolidation ma réponse originale puisque nous avons maintenant essentiellement le tableau complet:

• Vous atteint la limite de débit inhérente à la LinkedBlockingQueue (chaque file d'attente a un) en faisant put() extrêmement rapide de, où même take()s continue, avec aucun traitement ultérieur, ne peut pas suivre. (En passant, cela montre que dans cette structure, sur votre JVM et votre machine de toute façon, les put() sont au moins légèrement plus coûteux que les lectures).
• Étant donné qu'un verrou particulier est verrouillé par les consommateurs, l'ajout de threads grand public ne pourrait pas vous aider (si votre client effectuait un traitement et limitait le débit, il serait utile d'ajouter plus de consommateurs. un scénario avec plus d'un consommateurs (ou producteurs), vous pouvez essayer SynchronousQueue, ConcurrentLinkedQueue, et le prochain TransferQueue de jsr166y).

Quelques suggestions:

• Essayez de faire des objets plus gros grains, de sorte que les frais généraux de faire la queue chaque est équilibrée avec le travail réel qui est déchargé du fil produisant (dans votre cas, il semble que vous créez beaucoup de frais généraux de communication pour les objets qui représentent une quantité de travail négligeable)
• Vous pourriez également demander au producteur d'aider le consommateur en déchargeant un travail de consommation (il ne sert à rien d'attendre inutilement quand il y a du travail à faire).

/jour après John W. a justement souligné ma réponse initiale était trompeuse

Answer 2

Il est difficile de dire ce qui se passe sans savoir quelque chose au sujet du processus de remplissage.

Si addMyMessage est appelée moins fréquemment - peut-être à cause d'un problème de performance dans une partie de votre application - la méthode take doit attendre. De cette façon, il semble que take est le coupable, mais en fait c'est la partie de remplissage de votre application.

Answer 3

Il est possible que votre application soit affectée par les modifications liées au verrouillage de Java 6, en particulier la fonction de "verrouillage biaisé". Essayez de le désactiver en utilisant le commutateur -XX:-UseBiasedLocking et voyez si cela fait une différence.

Voir ce pour plus d'informations: http://java.sun.com/performance/reference/whitepapers/6_performance.html

Answer 4

Trouvé this interesting post sur les problèmes de performance en raison de la taille et la file d'attente collecte des ordures.

Answer 5

Ne peux rien dire à coup sûr. Mais vous pouvez essayer de changer l'implémentation BlockingQueue (juste comme une expérience).

Vous définissez la capacité initiale 50k et utilisez LinkedBlockingQueue. Essayez ArrayBlockingQueue avec la même capacité, vous pouvez également jouer avec le paramètre fair.

Answer 6

Je recommande généralement de ne pas utiliser LinkedBlockingQueue dans une zone de code sensible aux performances, utilisez une ArrayBlockingQueue. Il donnera un profil de récupération de place beaucoup plus agréable et est plus favorable au cache que le LinkedBlockingQueue.

Essayez l'ArrayBlockingQueue et mesurez les performances. Le seul avantage de LinkedBlockingQueue est qu'il peut être illimité, mais c'est rarement ce que vous voulez réellement.Si vous avez un cas où un consommateur échoue et que les files d'attente commencent à effectuer une sauvegarde, le fait d'avoir des files d'attente bornées permet au système de se dégrader correctement plutôt que de risquer OutOfMemoryErrors qui peut se produire si les files d'attente sont illimitées.

Answer 7

Voici quelques choses à essayer:

Remplacer le LinkedBlockingQueue avec un ArrayBlockingQueue. Il n'a pas de références qui pendent et il vaut mieux se comporter lorsque la file d'attente se remplit. Plus précisément, compte tenu de l'implémentation de LinkedBlockingQueue 1.6, le GC complet des éléments n'aura pas lieu tant que la file d'attente ne sera pas vide. Si le côté du producteur est constamment en train d'effectuer le côté consommateur, pensez à utiliser drain ou drainTo pour effectuer une opération de prise en masse.

Vous pouvez également demander à la file d'attente de prendre des tableaux ou des listes d'objets de message. Le producteur remplit une liste ou un tableau avec des objets de message et chaque put ou take déplace plusieurs messages avec le même temps de verrouillage. Pensez-y comme une secrétaire vous remettant une pile de messages «Pendant que vous étiez sorti» plutôt que de vous les remettre un à la fois.

Answer 8

Si les frais généraux de performance brute pour mettre et prendre objet de vos blockingqueues est votre goulot d'étranglement (et non le slow-producer/consumer problem), vous pouvez obtenir Amélioration considérable des performances avec le traitement par lot d'objets: par exemple, au lieu de mettre ou de prendre des objets à grain fin, vous mettez ou prenez des listes d'objets à granularité grossière.Voici un extrait de code:

ArrayBlockingQueue<List<Object>> Q = new ArrayBlockingQueue<List<Object>>(); 

// producer side 
List<Object> l = new ArrayList<Object>(); 
for (int i=0; i<100; i++) { 
    l.add(i); // your initialization here 
} 
Q.put(l); 

// consumer side 
List<Object> l2 = Q.take(); 
// do something 

Le traitement par lots peut augmenter vos performances d'un ordre de grandeur.