Java 使用JMS临时队列进行同步使用是一种好的做法吗？

如果我们使用使用“临时队列”的JMS请求/应答机制，那么该代码是可伸缩的吗

到目前为止，我们还不知道是每秒支持100个请求，还是每秒支持1000个请求

下面的代码是我正在考虑实现的代码。它以“同步”方式使用JMS。关键部分是创建“使用者”以指向为此会话创建的“临时队列”的位置。我只是不知道使用这样的临时队列是否是一种可伸缩的设计

  destination = session.createQueue("queue:///Q1");
  producer = session.createProducer(destination);
  tempDestination = session.createTemporaryQueue();
  consumer = session.createConsumer(tempDestination);

  long uniqueNumber = System.currentTimeMillis() % 1000;
  TextMessage message = session
      .createTextMessage("SimpleRequestor: Your lucky number today is " + uniqueNumber);

  // Set the JMSReplyTo
  message.setJMSReplyTo(tempDestination);

  // Start the connection
  connection.start();

  // And, send the request
  producer.send(message);
  System.out.println("Sent message:\n" + message);

  // Now, receive the reply
  Message receivedMessage = consumer.receive(15000); // in ms or 15 seconds
  System.out.println("\nReceived message:\n" + receivedMessage);

更新：

我发现了另一种模式，明白吗 其思想是对发送和接收都使用“常规”队列。但是，对于“同步”调用，为了获得所需的响应（即匹配请求），您可以使用“选择器”创建侦听接收队列的使用者

步骤：

    // 1. Create Send and Receive Queue.
    // 2. Create a msg with a specific ID
 final String correlationId = UUID.randomUUID().toString();
 final TextMessage textMessage = session.createTextMessage( msg );
 textMessage.setJMSCorrelationID( correlationId );

    // 3. Start a consumer that receives using a 'Selector'.
           consumer = session.createConsumer( replyQueue, "JMSCorrelationID = '" + correlationId + "'" );

因此，这种模式的区别在于，我们不会为每个新请求创建一个新的临时队列。 相反，所有响应只到达一个队列，但使用“选择器”确保每个请求线程只接收所关心的响应

---

我认为这里的缺点是您必须使用“选择器”。我还不知道这是不是比前面提到的模式更不受欢迎或更受欢迎。想法

创建临时队列不是免费的。毕竟，它是在代理上分配资源。话虽如此，如果您有一个未知的（之前）潜在未绑定的客户机数量（多个JVM，每个JVM有多个并发线程，等等），那么您可能没有选择。分配客户机队列并将其分配给客户机将很快失去控制

当然，你所画的是最简单的解决方案。如果你能得到交易量的真实数字，并且它的规模足够大，那就好了

在我考虑避免临时队列之前，我会更多地考虑限制客户机的数量并使客户机长寿。也就是说，在客户端创建一个客户机池，让池中的客户机在启动时创建临时队列、会话、连接等，在后续请求中重用它们，并在关闭时将它们拆下。然后，调优问题变成了池的最大/最小大小、修剪池的空闲时间以及池最大化时的行为（失败vs阻塞）。除非创建任意数量的临时JVM（在这种情况下，JVM启动开销会带来更大的扩展问题），否则它应该可以像其他任何东西一样扩展。毕竟，此时您分配的资源反映了系统的实际使用情况。真的没有比这少用的机会了

---

要避免的事情是创建和销毁大量免费的队列、会话、连接等。设计服务器端以允许从一开始就进行流式处理。如果需要的话，就去游泳。不管怎样，对于任何非琐碎的事情，您都需要。

关于post选择器中的更新，如果对消息头执行更新，就像您对相关ID所做的那样，那么它是非常有效的。对于共享队列，在相关ID上使用选择器也可以在内部执行此操作。

对于多个使用者，使用选择器将非常有效

但是，1000次请求/秒将非常多。如果性能出现问题，您可能希望在不同的实例之间分配一点负载

---

您可能需要详细说明请求与客户端的编号。如果客户端数量<10并且将保持相当静态，并且请求数量非常高，那么最具弹性和最快速的解决方案可能是为每个客户端提供静态回复队列。

也许我太迟了，但我本周花了一些时间在JMS中实现同步请求/回复。用超时扩展QueueRequester怎么样。我做了，并且至少在一台机器上（运行代理、请求者和回复者）进行了测试，结果表明该解决方案优于前面讨论的解决方案。另一方面，这取决于使用QueueConnection，这意味着您可能会被迫打开多个连接。

有趣的是，这一点的可扩展性实际上可能与其他响应所描述的相反

WebSphere MQ尽可能保存和重用动态队列对象。因此，尽管动态队列的使用不是免费的，但它确实可以很好地扩展，因为当队列被释放时，WMQ需要做的就是将句柄传递给请求新队列实例的下一个线程。在繁忙的QMgr中，当句柄从一个线程传递到另一个线程时，动态队列的数量将保持相对静态。严格地说，它不如重用单个队列快，但也不错

另一方面，尽管在

CORRELID

上建立索引速度很快，但性能与索引中的消息数成反比。如果队列深度开始构建，这也会产生影响。当应用程序在空队列上执行

GET

和

WAIT

时，没有延迟。但在深度队列中，QMgr必须搜索现有消息的索引，以确定回复消息不在其中。在您的示例中，这就是每秒搜索空索引和大索引1000次之间的区别

---

结果是，根据应用程序和负载的特点，1000个动态队列（每个队列有一条消息）实际上可能比1000个线程通过

CORRELID

的单个队列快。我建议在提交到特定设计之前进行大规模测试。

使用临时队列每次都要花费创建重新创建的成本。在高度并发的调用环境中，createProducer方法的成本会更高，并会影响性能，而不是使用缓存的生产者进行静态replyToQueue。

我一直面临同样的问题，决定将连接集中在无状态bean中。一个客户con

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

}

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