Is it a good practice to use JMS Temporary Queue for synchronous use?

后端 未结 7 867
有刺的猬
有刺的猬 2021-01-30 18:20

If we use JMS request/reply mechanism using \"Temporary Queue\", will that code be scalable?

As of now, we don\'t know if we will supporting 100 requests per second, or

相关标签:
7条回答
  • 2021-01-30 18:23

    Using selector on correlation ID on a shared queue will scale very well with multiple consumers.

    1000 requests / s will however be a lot. You may want to divide the load a bit between different instances if the performance turns out to be a problem.

    You might want to elaborate on the requests vs clients numbers. If the number of clients are < 10 and will stay rather static, and the request numbers are very high, the most resilient and fast solution might be to have static reply queues for each client.

    0 讨论(0)
  • 2021-01-30 18:26

    Maybe I'm too late but I spent some hours this week to get sync Request/Reply working within JMS. What about extending the QueueRequester with timeout. I did and at least testing on one single machine (running broker, requestor and replyer) showed that this solution outperforms the discussed ones. On the other side it depends on using a QueueConnection and that means you may be forced to open multiple Connections.

    0 讨论(0)
  • 2021-01-30 18:30

    Regarding the update in your post - selectors are very efficient if performed on the message headers, like you are doing with the Correlation ID. Spring Integration also internally does this for implementing a JMS Outbound gateway.

    0 讨论(0)
  • 2021-01-30 18:34

    Interestingly, the scalability of this may actually be the opposite of what the other responses have described.

    WebSphere MQ saves and reuses dynamic queue objects where possible. So, although use of a dynamic queue is not free, it does scale well because as queues are freed up, all that WMQ needs to do is pass the handle to the next thread that requests a new queue instance. In a busy QMgr, the number of dynamic queues will remain relatively static while the handles get passed from thread to thread. Strictly speaking it isn't quite as fast as reusing a single queue, but it isn't bad.

    On the other hand, even though indexing on CORRELID is fast, performance is inverse to the number of messages in the index. It also makes a difference if the queue depth begins to build. When the app goes a GET with WAIT on an empty queue there is no delay. But on a deep queue, the QMgr has to search the index of existing messages to determine that the reply message isn't among them. In your example, that's the difference between searching an empty index versus a large index 1,000s of times per second.

    The result is that 1000 dynamic queues with one message each may actually be faster than a single queue with 1000 threads getting by CORRELID, depending on the characteristics of the app and of the load. I would recommend testing this at scale before committing to a particular design.

    0 讨论(0)
  • 2021-01-30 18:34

    Using temporary queue will cost creating relyToProducers each every time. Instead of using a cached producers for a static replyToQueue, the method createProducer will be more costly and impact performance in a highly concurrent invocation environment.

    0 讨论(0)
  • 2021-01-30 18:40

    Ive been facing the same problem and decided to pool connections myself inside a stateless bean. One client connection has one tempQueue and lays inside JMSMessageExchanger object (which contains connectionFactory,Queue and tempQueue), which is bind to one bean instance. Ive tested it in JSE/EE environments. But im not really sure about Glassfish JMS pool behaviour. Will it actually close JMS connections, obtained "by hand" after bean method ends?Am I doing something terribly wrong?

    Also Ive turned off transaction in client bean (TransactionAttributeType.NOT_SUPPORTED) to send request messages immediately to the request queue.

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

    The same class is used in client (stateless bean) and server (@MessageDriven). RequestProducer and ResponseProducer are interfaces:

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

    Also I`ve read AMQ article about request-response implementation over AMQ: http://activemq.apache.org/how-should-i-implement-request-response-with-jms.html

    0 讨论(0)
提交回复
热议问题