Ist es eine gute Vorgehensweise, JMS Temporary Queue für synchrone Verwendung zu verwenden?

Interessant, die Skalierbarkeit dieser kann tatsächlich das Gegenteil von dem, was die anderen Antworten beschrieben habe.

WebSphere MQ speichert und wiederverwendet, dynamische queue-Objekten wo dies möglich ist. So, obwohl die Verwendung einer dynamischen Warteschlange ist nicht frei, es wird gut skalieren, weil wie die Schlangen sind befreit, alle, dass ein Fehler in WMQ Bedürfnisse zu tun ist, übergeben Sie den Griff, bis der nächste thread, fordert eine neue queue-Instanz. In einer belebten QMgr, die Anzahl der dynamischen Warteschlangen bleiben relativ statisch, während die Griffe weitergeleitet von thread zu thread. Streng genommen ist es nicht ganz so schnell, wie die Wiederverwendung einer einzelnen Warteschlange, aber es ist nicht schlecht.

Auf der anderen Seite, obwohl die Indizierung auf CORRELID ist schnell, Leistung ist invers zu der Anzahl der Nachrichten im index. Es macht auch einen Unterschied, wenn die queue-Tiefe beginnt zu bauen. Wenn die app geht ein GET mit WAIT auf eine leere Warteschlange, gibt es keine Verzögerung. Aber auf eine Tiefe Warteschlange, die QMgr suchen muss, der index der vorhandenen Nachrichten, um festzustellen, dass die Antwort-Nachricht ist nicht unter Ihnen. In deinem Beispiel ist der Unterschied zwischen der Suche eine leere index im Vergleich zu einem großen index 1,000 s von mal pro Sekunde.

Das Ergebnis ist, dass 1000 dynamische Warteschlangen mit einer Nachricht kann sich jeder wirklich schneller als eine einzelne Warteschlange mit 1000 threads immer von CORRELID je nach den Eigenschaften der app und der Last. Ich würde empfehlen dieses zu testen, die skaliert, bevor Begehen zu einem bestimmten design.

InformationsquelleAutor der Antwort T.Rob

Erstellen von temporären Warteschlangen ist nicht frei. Schließlich ist die Zuteilung der Ressourcen auf der broker(s). Having said, die, wenn Sie einen unbekannten (vor der hand) potentiell ungebundene Anzahl von clients (mehrere JVMs, die mehrere gleichzeitige threads pro JVM, etc) Sie dürfen keine Wahl haben. Pro-Zuweisung von client-Warteschlangen und Zuordnung zu Kunden würden aus der hand fallen.

Sicherlich, was haben Sie skizziert, ist die einfachste mögliche Lösung. Und wenn man real-zahlen für Umsatz und Skalen genug, fein.

Bevor ich Aussehen würde, zu verhindern, dass temporäre queues, ich würde schauen mehr auf die Begrenzung der Anzahl der Kunden und den Kunden lange gelebt. Das ist zu sagen, erstellen Sie eine client-pool auf der client-Seite, und haben Sie die Kunden in den pool erstellen der temporären queue, session, Verbindung, etc. beim Start Wiederverwendung bei nachfolgenden Anfragen und Riss diese dann auf Herunterfahren. Dann das tuning-problem zu einem der min/max-Größe auf den pool, was die idle-time zu beschneiden, den pool und das Verhalten (fail vs block), wenn der pool ausgeschöpft ist. Es sei denn, Sie erstellen eine beliebig große Anzahl von Transienten JVMs (in dem Fall haben Sie größere Skalierung Probleme, die nur von der JVM startup-overhead), sollte das doch so gut skalieren wie alles andere. Nach allem, an diesem Punkt die Ressourcen, die Sie zuweisen der tatsächlichen Nutzung des Systems. Gibt es wirklich keine Möglichkeit, weniger als das.

Ist die Sache zu vermeiden, ist die Schaffung und die Zerstörung eines großen unentgeltliche Anzahl der Warteschlangen, sessions, verbindungen, etc. Design der server-Seite ermöglichen das streaming von der get-go. Dann Lache wenn/Wann Sie es benötigen. Wie nicht, für alles, was nicht-trivial, Sie müssen.

InformationsquelleAutor der Antwort asudell

Habe ich vor dem gleichen problem und entschied, pool-verbindungen selbst innerhalb einer stateless bean. Einer client-Verbindung hat eine tempQueue und im inneren sieht JMSMessageExchanger-Objekt (enthält connectionFactory -, Queue-und tempQueue), die Bindung an eine bean-Instanz. Ich habe es getestet in JSE/EE-Umgebungen. Aber ich bin nicht wirklich sicher über Glassfish JMS-pool Verhalten.
Wird es eigentlich nahe JMS-verbindungen, erhalten "von hand" nach-bean-Methode beendet?Mache ich etwas furchtbar falsch???

Auch Ive deaktiviert Transaktion im client-bean (TransactionAttributeType.NOT_SUPPORTED) auf Anfrage senden Nachrichten sofort in der Warteschlange.

package net.sf.selibs.utils.amq;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.DeliveryMode;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageProducer;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TemporaryQueue;
import lombok.Getter;
import lombok.Setter;
import net.sf.selibs.utils.misc.UHelper;

public class JMSMessageExchanger {

    @Setter
    @Getter
    protected long timeout = 60 * 1000;

    public JMSMessageExchanger(ConnectionFactory cf) {
        this.cf = cf;
    }

    public JMSMessageExchanger(ConnectionFactory cf, Queue queue) {
        this.cf = cf;
        this.queue = queue;
    }
    //work
    protected ConnectionFactory cf;
    protected Queue queue;
    protected TemporaryQueue tempQueue;
    protected Connection connection;
    protected Session session;
    protected MessageProducer producer;
    protected MessageConsumer consumer;
    //status
    protected boolean started = false;
    protected int mid = 0;

    public Message makeRequest(RequestProducer producer) throws Exception {
        try {
            if (!this.started) {
                this.init();
                this.tempQueue = this.session.createTemporaryQueue();
                this.consumer = this.session.createConsumer(tempQueue);
            }
            //send request
            Message requestM = producer.produce(this.session);
            mid++;
            requestM.setJMSCorrelationID(String.valueOf(mid));
            requestM.setJMSReplyTo(this.tempQueue);
            this.producer.send(this.queue, requestM);
            //get response
            while (true) {
                Message responseM = this.consumer.receive(this.timeout);
                if (responseM == null) {
                    return null;
                }
                int midResp = Integer.parseInt(responseM.getJMSCorrelationID());
                if (mid == midResp) {
                    return responseM;
                } else {
                    //just get other message
                }
            }

        } catch (Exception ex) {
            this.close();
            throw ex;
        }
    }

    public void makeResponse(ResponseProducer producer) throws Exception {
        try {
            if (!this.started) {
                this.init();
            }
            Message response = producer.produce(this.session);
            response.setJMSCorrelationID(producer.getRequest().getJMSCorrelationID());
            this.producer.send(producer.getRequest().getJMSReplyTo(), response);

        } catch (Exception ex) {
            this.close();
            throw ex;
        }
    }

    protected void init() throws Exception {
        this.connection = cf.createConnection();
        this.session = this.connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        this.producer = this.session.createProducer(null);
        this.producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
        this.connection.start();
        this.started = true;
    }

    public void close() {
        UHelper.close(producer);
        UHelper.close(consumer);
        UHelper.close(session);
        UHelper.close(connection);
        this.started = false;
    }

}

Gleichen Klasse wird verwendet, um client (stateless bean) und server (@MessageDriven).
RequestProducer und ResponseProducer Schnittstellen:

package net.sf.selibs.utils.amq;

import javax.jms.Message;
import javax.jms.Session;

public interface RequestProducer {
    Message produce(Session session) throws Exception;
}
package net.sf.selibs.utils.amq;

import javax.jms.Message;

public interface  ResponseProducer extends RequestProducer{
    void setRequest(Message request);
    Message getRequest();
}

Zudem habe ich gelesen AMQ Artikel über Anfrage-Antwort-Implementierung über AMQ:
http://activemq.apache.org/how-should-i-implement-request-response-with-jms.html

InformationsquelleAutor der Antwort arbocdi