Extremely low message throughput with MQ 3.6

Question

We performed some load tests to determine maximum throughput of the Sun JMS framework when used in conditions similar to our application.
The achieved throughput is extremely low: around 10 messages / second while we expected around 100. Could you please verify what may be the reason?
We encountered one particular problem: the time of closing JMS producers increases much during the test. Message throughput decreases proportionally. Time periods of other phases of the JMS API usage remain constant. What can be the reason?
detailed information:
Our configuration used:
server machine:
cpu: Intel Celeron 2.8 Ghz
ram: 1GB
os: CentOS release 4.4 (Final), 2.6.9-42.0.3.EL
application server: Sun Java System Application Server Enterprise Edition 8.1 2005Q2 UR2
java version: 1.5.0_04
we use default imqbroker configuration
client machine:
Intel Celeron 2Ghz
ram: 512MB
os: Fedora Core release 3, 2.6.12-1.1381_FC3
java version: 1.4.02
Test description (find attached test unit sources presenting our way of using JMS API):
Load test is performed by running a number of concurrent test units against the JMS broker. Number of units is constant in time. Additionally, every unit test at the end of its life cycle launches another unit to keep long test time perspective.
Each test unit is self-contained. It contains of a producer and a consumer (MessageListener). It sends messages to itself . Also each message unit sleeps for some time to simulate message processing.
Messages are non-persistent, no durable subscriptions are used. All units are using one shared Queue for whole messaging. Message selectors are utilized to guarantee that messages are delivered to intended receiver.
By this test we wanted to determine a maximum value of message throughput for which all messages are delivered successfully and in some reasonable time (say less than 1 minute).
Some variations of test units are possible, e.g. JMS connections and/or sessions can be open/closed for every sent message or shared among multiple producers. But (contrary to our expectations) we encountered no visible differences in message throughput and message delivery time.
Code of test units:
Sender.java
package pl.ericpol.jmstest;
import javax.jms.Connection;
import javax.jms.JMSException;
import javax.jms.MessageProducer;
import javax.jms.Session;
public class Sender{
     private UnitTest unitTest = null;
     private Connection connection = null;
     private Session session = null;
     private MessageProducer producer = null;
     private String selector = null;
     public Sender(Connection con, Session session, MessageProducer producer, String selector, UnitTest unitTest){
     public void send() {
          try {
               boolean closeSession = false;
               boolean closeProducer = false;
               if(this.session == null){
                    this.session = this.connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
                    closeSession = true;
               if(this.producer == null){
                    this.producer = this.unitTest.createProducer(this.session);
                    closeProducer = true;
               this.producer.send(this.unitTest.createMessage(this.session, this.selector));
               if(closeProducer){
                    this.producer.close();
                    this.producer = null;
               if(closeSession){
                    this.session.close();
                    this.session = null;
          } catch (JMSException e) {
               e.printStackTrace();
Receiver.java
package pl.ericpol.jmstest;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TextMessage;
public class Receiver extends Thread implements MessageListener{
     private Connection connection = null;
     private Session session = null;
     private Destination destination = null;
     private MessageConsumer consumer = null;
     private Connection sendConnection = null;
     private Session sendSession = null;
     private MessageProducer producer = null;
     private String qname = null;
     private String selector = null;
     private int messagesToReceive = -1;
     private int delay = -1;
     private UnitTest unitTest = null;
     private boolean active = true;
     private long[][] localStats = null;
     private Boolean monitor = new Boolean(true);
     public Receiver(ConnectionFactory cf, Connection sendConnection, Session sendSession, MessageProducer producer,
               String code, UnitTest unit){
          try {
               this.connection = cf.createConnection();
               this.session = this.connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
               this.destination = this.session.createQueue(this.qname);
               this.consumer = this.session.createConsumer(this.destination, UnitTest.KEY + " = '" + code + "'");
               this.consumer.setMessageListener(this);
               this.connection.start();
               this.producer = producer;
               this.sendSession = sendSession;
               this.sendConnection = sendConnection;
          } catch (JMSException e) {
               e.printStackTrace();
          } catch (NumberFormatException e1) {
               e1.printStackTrace();
     public void run() {
          if(this.consumer == null){
          } else {
               this.sleep(0);
               this.close();
               TestManager.getInstance().unitTestFinished();
     public synchronized void onMessage(Message arg0) {
          Message message = arg0;
          if(this.active){
               if(message == null){
               } else {
                    if(message instanceof TextMessage){
                              this.registerDeliveryTime(this.localStats.length - this.messagesToReceive, message);
                              this.sleep(this.delay);
                              synchronized(this.monitor){
                                   if(--this.messagesToReceive == 0){
                                        this.unitTest.messagesReceived();
                                   } else {
                                        if(this.active){
                                             this.send();     
                    } else {
          } else {
          if(! this.active){
               this.notify();
     public synchronized void deactivate(){
     public int getMessagesToReceive(){
          return this.messagesToReceive;
     private void send(){
          try {
               boolean closeSession = false;
               boolean closeProducer = false;
               if(this.sendSession == null){
                    this.sendSession = this.sendConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
                    closeSession = true;
               if(this.producer == null){
                    this.producer = this.unitTest.createProducer(this.sendSession);
                    closeProducer = true;
               this.producer.send(this.unitTest.createMessage(this.sendSession, this.selector));
               if(closeProducer){
                    this.producer.close();
                    this.producer = null;
               if(closeSession){
                    this.sendSession.close();
                    this.sendSession = null;
          } catch (JMSException e) {
               e.printStackTrace();
     private synchronized void sleep(int delay){
     private void registerDeliveryTime(int index, Message message){
     private synchronized void close(){
          try {
               if(this.producer != null){
                    this.producer.close();
               if(this.sendSession != null){
                    this.sendSession.close();
                    this.sendSession = null;
               if(this.sendConnection != null){
                    this.sendConnection.close();
                    this.sendConnection = null;
               if(this.consumer != null){
                    this.consumer.close();
                    this.consumer = null;
               if(this.session != null){
                    this.session.close();
                    this.session = null;
               if(this.connection != null){
                    this.connection.close();
                    this.connection = null;
          } catch (JMSException e) {
               e.printStackTrace();
TestUnit.java
package pl.ericpol.jmstest;
import java.util.HashMap;
import java.util.Iterator;
import javax.jms.Connection;
import javax.jms.DeliveryMode;
import javax.jms.JMSException;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TextMessage;
import com.sun.messaging.ConnectionFactory;
import com.sun.messaging.QueueConnectionFactory;
public class UnitTest extends Thread{
     public static final String KEY = "Type";
     private ConnectionFactory cf = null;
     private Connection sendConnection = null;
     private Session sendSession = null;
     private MessageProducer producer = null;
     private int delay = -1;
     private int messagesPerCall = -1;
     private int loop = -1;
     private int timeOut = -1;
     private int maxLoops = -1;
     private boolean waitingFlag = false;
     private boolean messagesReceived = false;
     public UnitTest(int loop){
          try {               
               this.cf = new QueueConnectionFactory();
               this.applyProps(this.cf, Properties.getInstance().getSunProps());
               this.sendConnection = this.cf.createConnection();
               if(sharedProducer){
                    this.sendSession = this.sendConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
                    this.producer = this.createProducer(this.sendSession);
               } else if(sharedSession){
                    this.sendSession = this.sendConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
               this.sendConnection.start();
          } catch (NumberFormatException e){
               MyLogger.logger.error("number format exception!!");
          } catch (JMSException e) {
               e.printStackTrace();
     public void run(){
          String selector = String.valueOf(Randomizer.getRandInt(Integer.MAX_VALUE));
          Receiver receiver = new Receiver(this.cf, this.sendConnection, this.sendSession, this.producer, selector, this);
          receiver.start();
          long startTime = System.currentTimeMillis();
          this.send(selector);
          synchronized (this) {
               if(! this.messagesReceived){
                    this.sleep(this.timeOut);     
          long finishTime = System.currentTimeMillis();
          receiver.deactivate();
          if(++this.loop < this.maxLoops && TestManager.getInstance().getStatus()){
               UnitTest newTest = new UnitTest(this.loop);
               newTest.start();
          } else {
               TestManager.getInstance().workerFinished();
     public void messagesReceived(){
     private synchronized void sleep(int delay){
     private void applyProps(ConnectionFactory cf, HashMap props){
     private void send(String selector){
          Sender sender = new Sender(this.sendConnection, this.sendSession, this.producer, selector, this);
          sender.send();
     public MessageProducer createProducer(Session session){
          MessageProducer producer = null;
          String qname = (String) Properties.getInstance().getOtherProps().get(Properties.JMS_QUEUE_NAME);
          try {
               producer = session.createProducer(session.createQueue(qname));
               producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
          } catch (JMSException e) {
               e.printStackTrace();
          return producer;
     public TextMessage createMessage(Session session, String selector){
          try {
               TextMessage message = session.createTextMessage();
               message.setStringProperty(UnitTest.KEY, selector);
               String messageLenAsString = (String) Properties.getInstance().getOtherProps().get(Properties.JMS_MESSAGE_LENGTH);
               int messageLen = Integer.parseInt(messageLenAsString);
               StringBuffer buf = new StringBuffer();
               buf.append(selector).append("-");
               for(int i = 0; i < messageLen; i++){
                    buf.append("x");
               message.setText(buf.toString());
               return message;
          } catch(NumberFormatException e){
               MyLogger.logger.error("bad message length!!");
          } catch (JMSException e) {
               e.printStackTrace();
          return null;
}

Answer 1

If you go here:
http://www.sun.com/software/solaris/get.jsp
and
1.Check Sun Java Enterprise (or the Sun Java Application Platform Suite),
2.Click Get Download and Media
3. Then select Systems for windows (the bar at the top)
I beleive you can get Message Queue 3.6 SP3 from it, by only installing the Message Queue component.
Note: it is a large download (500 Mb for Application Platform), especially for Sun Java Enterprise...
TE