Java 队列持续时慢HornetQ生成器

我在horntQ中尝试了持久队列。我分别举了两个例子（生产者、消费者）。我的消费者工作正常，但制作人花了太多时间来完成发送消息。我既单独运行，也一起运行。有什么问题吗？ 我的代码是：

public  class HornetProducer implements Runnable{

    Context ic = null;
    ConnectionFactory cf = null;
    Connection connection =  null;
    Queue queue = null;
    Session session = null;
    MessageProducer publisher =  null;
    TextMessage message = null;
    int messageSent=0;

     public synchronized static Context getInitialContext()throws javax.naming.NamingException {

            Properties p = new Properties( );
            p.put(Context.INITIAL_CONTEXT_FACTORY,"org.jnp.interfaces.NamingContextFactory");
            p.put(Context.URL_PKG_PREFIXES," org.jboss.naming:org.jnp.interfaces");
            p.put(Context.PROVIDER_URL, "jnp://localhosts:1099");

            return new javax.naming.InitialContext(p);
        }  

    public HornetProducer()throws Exception{            

        ic = getInitialContext();
        cf = (ConnectionFactory)ic.lookup("/ConnectionFactory");
        queue = (Queue)ic.lookup("queue/testQueue2");
        connection = cf.createConnection();
        session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);        
        publisher = session.createProducer(queue);
        connection.start();

    }

    public void publish(){      
        try{        

            message = session.createTextMessage("Hello!");
            System.out.println("StartDate: "+new Date());

            for(int i=0;i<10000;i++){                   
                 messageSent++;              
                 publisher.send(message);                
            }
            System.out.println("EndDate: "+new Date());
        }catch(Exception e){
            System.out.println("Exception in Consume: "+ e.getMessage());
        }           
    }

    public void run(){
         publish();
    }

    public static void main(String[] args) throws Exception{

        new HornetProducer().publish();    
    }

}

公共类HornetProducer实现可运行{
上下文ic=null；
ConnectionFactory cf=null；
连接=空；
队列=null；
会话=空；
MessageProducer publisher=null；
TextMessage=null；
int messageSent=0；
公共同步静态上下文getInitialContext（）引发javax.naming.NamingException{
属性p=新属性（）；
p、 put（Context.INITIAL_Context_FACTORY，“org.jnp.interfaces.NamingContextFactory”）；
p、 put（Context.URL_PKG_前缀，“org.jboss.naming:org.jnp.interfaces”）；
p、 put（Context.PROVIDER\u URL，“jnp://localhosts:1099");
返回新的javax.naming.InitialContext（p）；
}  
public HornetProducer（）引发异常{
ic=getInitialContext（）；
cf=（ConnectionFactory）ic.lookup（“/ConnectionFactory”）；
queue=（queue）ic.lookup（“queue/testQueue2”）；
connection=cf.createConnection（）；
会话=connection.createSession（false，session.AUTO_-ACKNOWLEDGE）；
publisher=session.createProducer（队列）；
connection.start（）；
}
public void publish（）{
试试{
message=session.createTextMessage（“你好！”）；
System.out.println（“开始日期：+新日期（））；
对于（int i=0；i您正在以非事务方式持续发送这些消息。这意味着，每个发送的消息都必须单独完成

这意味着对于您发送的每一条消息，您必须进行到服务器的网络往返，并等待它完成持久性，然后才能发送另一条消息

如果在这种情况下有多个生产者，hornetq将批处理这两个生产者，这样可以节省大量时间（即服务器将批处理许多写入请求）

如果您想加快单个生产者的发送速度，可能应该使用事务

例如：

I-将会话更改为事务处理：

session = connection.createSession(true, Session.SESSION_TRANSACTIONED); 

II-每N条消息提交一次：

   for(int i=0;i<10000;i++){                   
         messageSent++;              
         publisher.send(message);  
         if (messageSent % 1000 == 0) session.commit();              
    }
    session.commit();

用于（int i=0；我等待您的答复。那么，哪种方法更好：将日志同步设置为false，还是按照您的建议对每个会话进行批处理。假设只有一个会话，并且所有生产者都同步以使用同一个会话？这完全取决于您的需要。将日志同步设置为false将使系统停止同步，最终您可能会错过失败情况下的数据。最佳方法是批处理事务…在一次提交时发送多条消息。在一次提交时使用多条消息（ACK）。这是否适用于嵌入式和核心api（不使用jms）？我没有连接对象，只有ClientSessionFactory。我看到了一个方法CreateTransactionSession（），这就是我在我的例子中使用的吗？它实际上…只是把这些东西翻译成CoreAPI，你就有了相同的语义。