usage: java MQJavaRoundTrip <ltargs>
 Controller properties:
  -n <clients>
 (parallel threads)
  -d <duration>
 (in seconds - 0=never stop)
  -z (quiet, minimal output)
  -v <interval>
 (statistics interval)
 Queue manager properties:
  -qm <qm>
 (queue manager name)
  -i <queue>
 (put requests to)
  -o <queue>
 (get replies from)
 Connection properties for Bindings :
  -b (use local bindings connection)
  -t (use trusted/fastpath bindings, must use -b too)
 Connection properties for TCP/IP client :
  -h <hostname>
 (QM machine)
  -c <channel>
 (QM svrconn - defaults to SYSTEM.DEF.SVRCONN)
  -p <port>
 (QM listener port - defaults to 1414)
 Message properties:
  -f <file>
 (user data to send)
  -x (use transactions one-per-message)
  -s (use persistent messages)
  -mc (message character set)
  -me (message encoding)
  -mf (message format)
  -id (use get-correlation-id from sent-mesg-id)
  -gid (fixed correlation id per thread)
  -w <timeout>
 (message wait timeout in seconds)
 

import com.ibm.mq.*;
import java.io.*;
import java.util.ArrayList;
import java.util.Properties;
import java.util.Iterator;

public class MQJavaRoundTrip extends Thread {

	private static MQJavaRoundTrip instance = null;
	private boolean shutdown = false;
	private final ArrayList workers = new ArrayList();
	private Thread stats = null;
	final Properties arguments = new Properties();
	private byte[] inputFileBytes = null;
	private final java.text.NumberFormat numberFormat =
		java.text.NumberFormat.getInstance();
	boolean verbose = true;

	private MQJavaRoundTrip() {
		super("MQJavaRoundTrip");
		numberFormat.setMinimumFractionDigits(2);
		numberFormat.setMaximumFractionDigits(2);
		numberFormat.setGroupingUsed(false);
	}

	public static MQJavaRoundTrip getInstance() {
		if (instance == null) {
			instance = new MQJavaRoundTrip();
		}
		return instance;
	}

	void signalShutdown() {
		shutdown = true;
		interrupt();
	}

	public static void main(String args[]) {
		getInstance().parseArguments(args);
		getInstance().start();
	}

	public void run() {

		try {

			{
				if ( verbose ) System.out.println("Testing settings");
				MQQueueManager qm = getQueueManagerConnection();
				if ( verbose ) System.out.println("Connection to QM OK");
				MQQueue putQueue =
					qm.accessQueue(
						arguments.getProperty("i"),
						MQC.MQOO_OUTPUT
							| MQC.MQOO_INQUIRE
							| MQC.MQOO_FAIL_IF_QUIESCING);
				MQQueue getQueue =
					qm.accessQueue(
						arguments.getProperty("o"),
						MQC.MQOO_INPUT_SHARED
							| MQC.MQOO_INQUIRE
							| MQC.MQOO_FAIL_IF_QUIESCING);
				if ( verbose ) System.out.println("Connection to Queues OK");

				getQueue.close();
				putQueue.close();
				qm.disconnect();
			}

			readDataFromFile();

			createClientThreads();

			startStatisticsThread();

			startClientThreads();

			// Wait for the end fo the test
			int duration = Integer.parseInt(arguments.getProperty("d")) * 1000;
			if (duration <= 0) {
				((Thread) workers.get(0)).join();
			} else {
				Thread.sleep(duration);
			}

		} catch (InterruptedException e) {
			// No-op
		} catch (Throwable e) {
			// Display all other errors
			System.out.println(e);
			e.printStackTrace();
		} finally {
			shutdown = true;

			if ( verbose ) System.out.println("Instructing threads to stop");
			if (stats != null)
				stats.interrupt();
			// signal workers to die ....
			Iterator iter = workers.iterator();
			while (iter.hasNext()) {
				ClientThread worker = (ClientThread) iter.next();
				worker.shutdown = true;
				worker.interrupt(); // wake them if they are waiting
			} // end while workers

			if ( verbose ) System.out.println("Waiting for threads");
			iter = workers.iterator();
			try {
				while (iter.hasNext())
					 ((Thread) iter.next()).join();
			} catch (InterruptedException e) {}

			// Collect overall message rates
			iter = workers.iterator();
			double rate = 0;
			while (iter.hasNext()) {
				ClientThread worker = (ClientThread) iter.next();
				rate += (double) (worker.numberOfMessages * 1000)
					/ worker.runlength;
				worker.interrupt(); // wake them if they are waiting
			} // end while workers
			System.out.println(
				"Total rt/sec=" + numberFormat.format(rate));

		} // end try/catch/finally
	} // end run()

	private void startClientThreads() throws Exception {
		Iterator iter = workers.iterator();
		while (iter.hasNext()) {
			ClientThread worker = (ClientThread) iter.next();
			Thread.sleep(250 + (int) (Math.random() * 500));
			worker.start();
		} // end while
	} // end startClientThreads

	MQQueueManager getQueueManagerConnection() throws MQException {

		int connectionoptions = MQC.MQCNO_NONE;

		boolean bindings = arguments.getProperty("b") != null;
		if (bindings) {
			boolean fastpath = arguments.getProperty("f") != null;
			if (fastpath) {
				connectionoptions = MQC.MQCNO_FASTPATH_BINDING;
			} else {
				connectionoptions = MQC.MQCNO_STANDARD_BINDING;
			} // End elseif fastpath bindings
		} else { // End if bindings
			// if client connections
			MQEnvironment.hostname = arguments.getProperty("h");
			MQEnvironment.channel = arguments.getProperty("c");
			MQEnvironment.port = Integer.parseInt(arguments.getProperty("p"));
		}

		return new MQQueueManager(
			arguments.getProperty("qm"),
			connectionoptions);

	} // End getQueueManagerConnection

	private void createClientThreads() throws Exception {

		int nThreads = Integer.parseInt(arguments.getProperty("n"));

		for (int i = 1; i <= nThreads; i++) {

			String name = "Client" + i;
			if (arguments.getProperty("gid") != null) {
				byte addr[] = java.net.InetAddress.getLocalHost().getAddress();
				byte bytes[] = new byte[24];
				System.arraycopy(addr, 0, bytes, 0, addr.length);
				bytes[20] = (byte) i;
				bytes[21] = (byte) (i>> 8);
				bytes[22] = (byte) (i >> 16);
				bytes[23] = (byte) (i >> 24);

				workers.add(new ClientThread(name, bytes));
			} else {
				workers.add(new ClientThread(name));
			}

		} // end foreach thread
	} // end createClientThreads

	private void readDataFromFile() throws Exception {

		File theFileToRead = new File(arguments.getProperty("f"));
		inputFileBytes = new byte[(int) theFileToRead.length()];

		BufferedInputStream bIS =
			new BufferedInputStream(new FileInputStream(theFileToRead));
		bIS.read(inputFileBytes);
		bIS.close();

	} // End readDataFromFile

	// Create a new copy of the message
	MQMessage createMessage() throws Exception {

		MQMessage putMessage = new MQMessage();
		if (arguments.getProperty("mc") != null)
			putMessage.characterSet =
				Integer.parseInt(arguments.getProperty("mc"));
		if (arguments.getProperty("me") != null)
			putMessage.encoding = Integer.parseInt(arguments.getProperty("me"));
		if (arguments.getProperty("mf") != null)
			putMessage.format = arguments.getProperty("mf");
		putMessage.messageFlags = MQC.MQMT_REQUEST;
		if (arguments.getProperty("s") != null) {
			putMessage.persistence = MQC.MQPER_PERSISTENT;
		} else {
			putMessage.persistence = MQC.MQPER_NOT_PERSISTENT;
		}

		putMessage.write(inputFileBytes);

		return putMessage;
	} // end createMessage

	private void parseArguments(String[] args) {

		String currentkey = null;
		String currentvalue = "";
		arguments.setProperty("c", "SYSTEM.DEF.SVRCONN");
		arguments.setProperty("p", "1414");
		arguments.setProperty("n", "1");
		arguments.setProperty("d", "60");
		arguments.setProperty("w", "5");

		if (args.length == 0)
			printUsage();

		for (int i = 0; i < args.length; i++) {
			if (args[i].startsWith("-")) {
				if (currentkey != null) {
					arguments.setProperty(currentkey, currentvalue);
				}
				currentkey = args[i].substring(1);
				currentvalue = "true";
			} else if (currentvalue.equals("true")) {
				currentvalue = args[i];
			}
		} // end for
		if (currentkey != null)
			arguments.setProperty(currentkey, currentvalue);

		if ( arguments.getProperty("z")!=null ) verbose = false;

	} // end parseArguments

	private void printUsage() {
		System.out.println(
			"usage: java " + this.getClass().getName() + " <args;>");

		System.out.println(" Controller properties:");
		System.out.println(" -n <clients>     (parallel threads)");
		System.out.println(" -d <duration>    (in seconds - 0=never stop)");
		System.out.println(" -z               (quiet, minimal output)");
		System.out.println(" -v <interval>    (statistics interval)");		

		System.out.println(" Queue manager properties:");
		System.out.println(" -qm <qm>          (queue manager name)");
		System.out.println(" -i <queue>       (put requests to)");
		System.out.println(" -o <queue>       (get replies from)");

		System.out.println(" Connection properties for Bindings :");
		System.out.println(" -b               (use local bindings connection)");
		System.out.println(
			" -t               (use trusted/fastpath bindings, must use -b too)");

		System.out.println(" Connection properties for TCP/IP client :");
		System.out.println(" -h <hostname>    (QM machine)");
		System.out.println(
			" -c <channel>
			     (QM svrconn - defaults to SYSTEM.DEF.SVRCONN)");
		System.out.println(
			" -p <port>        (QM listener port - defaults to 1414)");

		System.out.println(" Message properties:");
		System.out.println(" -f <file>        (user data to send)");
		System.out.println(
			" -x               (use transactions one-per-message)");
		System.out.println(" -s               (use persistent messages)");
		System.out.println(" -mc              (message character set)");
		System.out.println(" -me              (message encoding)");
		System.out.println(" -mf              (message format)");
		System.out.println(
			" -id              (use get-correllation-id from sent-mesg-id)");
		System.out.println(
			" -gid             (fixed correllation id per thread)");
		System.out.println(
			" -w <timeout>     (message wait timeout in seconds)");

		System.exit(0);
	} // end printUsage

	private final void startStatisticsThread() throws Throwable {

		stats = new Thread("Stats") {
			private int prev[];
			private int curr[] = null;
			private void getValues() {
				// Get a snapshot of current "total messages"
				prev = curr;
				curr = new int[workers.size()];
				int i = 0;
				Iterator iter = workers.iterator();
				while (iter.hasNext() && i < curr.length) {
					ClientThread worker = (ClientThread) iter.next();
					curr[i++] = worker.numberOfMessages;
				}
			}
			public void run() {
				int diff;
				int total;
				final int interval = Integer.parseInt( arguments.getProperty("v") );
				final StringBuffer sb = new StringBuffer();

				getValues();

				while (!shutdown) {

					sb.setLength(0);
					try {
						Thread.sleep(interval * 1000);
						getValues();
						total = 0;
						// Calculate difference from last snapshot
						for (int j = 0; j < curr.length; j++) {
							diff = curr[j] - prev[j];
							total += diff;
						}
						sb.append("rt/sec=").append(
							numberFormat.format((double)
							     total / interval));

						System.out.println(sb);

					} catch (InterruptedException e) {}

				} // end while
			} // end run
		}; // end inner stats class
		stats.setDaemon(true);
		stats.start();
		
	} // end startstatisticsthread

} // End of file

import java.util.Date;

import com.ibm.mq.*;
//import com.ibm.mq.jms.services.ConfigEnvironment;

public class ClientThread extends Thread {

	private byte[] fixedCorrelId = null;
	private final static MQJavaRoundTrip parent = 
	    MQJavaRoundTrip.getInstance();
	int numberOfMessages = 0;
	boolean shutdown = false;
	long runlength = 0;

	public ClientThread(String name) {
		super(name);
	}

	public ClientThread(String name, byte[] correlId) {
		super(name);
		this.fixedCorrelId = correlId;
	}

	public void run() {

		MQQueueManager queueManager = null;
		MQQueue putQueue = null;
		MQQueue getQueue = null;

		if ( parent.verbose ) System.out.println(getName() + " : START");
		boolean transacted = parent.arguments.getProperty("x") != null;
		boolean useCorrelId =
			(parent.arguments.getProperty("id") != null)
				|| (fixedCorrelId != null);
		boolean copyCorrelId =
			(parent.arguments.getProperty("id") != null)
				&& (fixedCorrelId == null);

		// SETUP MESSAGES AND OPTIONS			
		MQPutMessageOptions pmo = new MQPutMessageOptions();
		MQGetMessageOptions gmo = new MQGetMessageOptions();

		gmo.waitInterval = 
			Integer.parseInt(parent.arguments.getProperty("w")) * 1000;
		gmo.matchOptions =
			useCorrelId ? MQC.MQMO_MATCH_CORREL_ID : MQC.MQMO_NONE;
		gmo.options = MQC.MQGMO_WAIT | MQC.MQGMO_FAIL_IF_QUIESCING;
		gmo.options |= transacted
			? MQC.MQGMO_SYNCPOINT
			: MQC.MQGMO_NO_SYNCPOINT;

		pmo.options = 
		    MQC.MQPMO_FAIL_IF_QUIESCING | MQC.MQPMO_NEW_MSG_ID;
		pmo.options |= transacted
			? MQC.MQPMO_SYNCPOINT
			: MQC.MQPMO_NO_SYNCPOINT;

		long startTime = 0;

		try {

			MQMessage outMessage = parent.createMessage();
			MQMessage inMessage = new MQMessage();

			if (fixedCorrelId != null) {
				outMessage.correlationId = fixedCorrelId;
				inMessage.correlationId = fixedCorrelId;
			}

			// Make connections to WMQ resources 
			queueManager = parent.getQueueManagerConnection();
			putQueue =
				queueManager.accessQueue(
					parent.arguments.getProperty("i"),
					MQC.MQOO_OUTPUT | MQC.MQOO_FAIL_IF_QUIESCING);
			getQueue =
				queueManager.accessQueue(
					parent.arguments.getProperty("o"),
					MQC.MQOO_INPUT_SHARED | MQC.MQOO_FAIL_IF_
					    QUIESCING);
			if ( parent.verbose ) System.out.println(getName() + ": connected");

			startTime = new Date().getTime();
			while (!shutdown) {

				
 {
					putQueue.put(outMessage, pmo);
					if (transacted) queueManager.commit();
					if (copyCorrelId) inMessage.correlationId = 
					    outMessage.messageId;
					getQueue.get(inMessage, gmo);
					if (transacted) queueManager.commit();
					numberOfMessages++;
				} catch (MQException e) {
					if (e.reasonCode == 
					    MQException.MQRC_NO_MSG_AVAILABLE)
						System.err.println(
							getName()
							     + " : Cannot see a response to message "
							+outMessage.messageId);
					throw e;
				} // End try catch

			} // End while ! shutdown
			
		} catch (Throwable e) {
			// Handle a fatal error
			System.err.println(
				getName() + " : Fatal Error.  Exception follows: \n" + e);
			parent.signalShutdown();
	
		} finally {
			// Clear up code carefully in fair weather or foul.
			runlength = new Date().getTime() - startTime;
			if (getQueue != null) {
				if ( parent.verbose ) System.out.println(
					getName() + " : Closing queue " + getQueue.name);
				try {
					getQueue.close();
				} catch (MQException e) {} finally {
					getQueue = null;
				}
			}
			if (putQueue != null) {
				if ( parent.verbose ) System.out.println(
					getName() + " : Closing queue " + putQueue.name);
				try {
					putQueue.close();
				} catch (MQException e) {} finally {
					putQueue = null;
				}
			}
			if (queueManager != null) {
				if ( parent.verbose ) System.out.println(
					getName()
						+ " : Closing queue manager "
						+ queueManager.name);
				try {
					queueManager.disconnect();
				} catch (MQException e) {} finally {
					queueManager = null;
				}
			}
			if ( parent.verbose ) System.out.println(getName() + " : STOP");
		} // End try/catch/finally
	} // End run method
}