public void publish(String topicName, int qos, byte[] payload, boolean retained) throws Throwable {
    // Use a state machine to decide which step to do next. State change occurs
    // when a notification is received that an MQTT action has completed

    state = BEGIN;

    while (state != FINISH) {
        switch (state) {
        case BEGIN:
            // Connect using a non-blocking connect
            if (client.isConnected()) {
                donext = true;
                state = CONNECTED;
            }
            break;
        case CONNECTED:
            // Publish using a non-blocking publisher
            Publisher pub = new Publisher();
            pub.doPublish(topicName, qos, payload, retained);
            break;
        case ERROR:
            log("Error is received!");
            throw ex;
        case PUBLISHED:
            state = FINISH;
            donext = true;
            break;
        }

        if (state != FINISH) {
            // Wait(6 seconds) until notified about a state change and then perform next action.
            waitForStateChange(6000);
        }
    }
}

/**
 * Publish in a non-blocking way and then sit back and wait to be
 * notified that the action has completed.
 */
public class Publisher {
    public void doPublish(String topicName, int qos, byte[] payload, boolean retained) {
        // Send / publish a message to the server
        // Get a token and setup an asynchronous listener on the token which
        // will be notified once the message has been delivered
        MqttMessage message = new MqttMessage(payload);
        message.setQos(qos);
        message.setRetained(retained);

        String time = new Timestamp(System.currentTimeMillis()).toString();
        log("Publishing at: "+time+ " to topic \""+topicName+"\" qos "+qos);

        // Setup a listener object to be notified when the publish completes.
        //
        IMqttActionListener pubListener = new IMqttActionListener() {
            public void onSuccess(IMqttToken asyncActionToken) {
                log("Publish Completed");
                state = PUBLISHED;
                carryOn();
            }

            public void onFailure(IMqttToken asyncActionToken, Throwable exception) {
                ex = exception;
                state = ERROR;
                log ("Publish failed" +exception);
                carryOn();
            }

            public void carryOn() {
                synchronized (waiter) {
                    donext=true;
                    waiter.notifyAll();
                }
            }
        };

        try {
            // Publish the message
            client.publish(topicName, message, "Pub sample context", pubListener);
        } catch (MqttException e) {
            state = ERROR;
            donext = true;
            ex = e;
        }
    }
}

client.publish(topicName, message, "Pub sample context", pubListener);

package sample;

import org.eclipse.paho.client.mqttv3.IMqttActionListener;
import org.eclipse.paho.client.mqttv3.IMqttToken;
import org.eclipse.paho.client.mqttv3.MqttAsyncClient;
import org.eclipse.paho.client.mqttv3.MqttException;
import org.eclipse.paho.client.mqttv3.MqttMessage;

public class PublisherExample {
	
	private boolean pubComplete;
	private boolean pubAttempted;
	static MqttAsyncClient asyncClient;
	String topic        = "/acTest";
	int qos 			= 0;
    String broker       = "tcp://localhost:1883";
    String clientId     = "JavaSample";
	
	public PublisherExample(){
		try {
			asyncClient = new MqttAsyncClient(broker, clientId);
		} catch (MqttException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
			
		PublisherExample publisherExample = new PublisherExample();
		publisherExample.publishMessage();
			
	}
	
	
	public void publishMessage() {
		try {
		IMqttActionListener pubListener = new IMqttActionListener() {
			
			@Override
			public void onSuccess(IMqttToken asyncActionToken) {
				setPubComplete(true);
				System.out.println("Publish Success!");
				
			}
			
			@Override
			public void onFailure(IMqttToken asyncActionToken, Throwable exception) {
				setPubAttempted(false);
				System.out.println("Publish Failure!");
				
			}
		};
    	
	    	while(!pubComplete){
	    		if(!asyncClient.isConnected()){
	    			// Client is not connected
		    		asyncClient.connect();
		    	} else {
		    		while(!pubAttempted){
			    		// Client is connected
			    		MqttMessage msg = new MqttMessage();
			    		msg.setPayload("Hello World!".getBytes());
			    		msg.setQos(0);
			    		System.out.println("Attempting Publish");
			    		asyncClient.publish("/test", msg, null, pubListener);
			    		setPubAttempted(true);
		    		}
		    	}
	    		Thread.sleep(1000);
	    	}
    	System.out.println("Publish Complete!");
    	} catch (Exception ex){
    		System.err.println("Inturrupted");
    		ex.printStackTrace();
    	}
	}
	
	public void setPubComplete(boolean pubComplete){
		this.pubComplete = pubComplete;
	}
	
	public void setPubAttempted(boolean pubAttempted){
		this.pubAttempted = pubAttempted;
	}

}