Open topic with navigation

TIBCO GridServer® 7.1.0

# Asynchronous and Parallel Processing Requests

A client can use the `submit` method instead of the `execute` method of `Service` to perform a remote invocation without waiting for the result. This allows the caller to make many asynchronous requests in parallel — with these requests being executed in parallel if the resources are available to do so. In addition to the method name and argument, the `submit` method takes a callback object that implements the `ServiceInvocationHandler` interface. This interface has a `handleResponse` method that is called with the method’s return value in the event of a normal response, and a `handleError` message that is called if an error occurs. The submit method returns an integer that uniquely identifies the particular call; this unique ID is passed as the second argument to the `ServiceInvocationHandler` methods, so that you can match the response with the request if need be.

To use the submit method, we first require a class implementing `ServiceInvocationHandler`. The `handleResponse` method displays the response and adds it to a total.

    // Handler for Service Clients
    static class AdderHandler implements ServiceInvocationHandler {
        public void handleError(ServiceInvocationException e, int id) {
            System.out.println("Error from " + id + ": " + e);
        }
        public void handleResponse(Serializable response, int id) {
            System.out.println("Response from " + id + ": " + response);
            _total += ((Double)response).doubleValue();
        }
        public double getTotal() {
            return _total;
        }
        private double _total = 0;
    }

Now we can invoke the `submit` method:

    // Perform Asynchronous adds
    AdderHandler handler = new AdderHandler();
    for (int i=0; i < 10; i++) {
        s.submit("add", new Object[] { new Double(i), new Double(i) }, handler);
    }
    // Wait until all the invocations have returned
    s.waitUntilInactive(0);
    System.out.println("Total: " + handler.getTotal());

This code first creates a `ServiceInvocationHandler`, and then it calls `submit` several times. To wait for all the responses to arrive, the call to `waitUntilInactive` causes the current thread to wait until all outstanding requests have finished. The argument is a timeout value in milliseconds; an argument of zero means wait indefinitely.

Did you find this helpful?

Yes No
Great!
Thanks for taking the time to give us some feedback.
Sorry about that

Why wasn't this helpful? (check all that apply)

Could not find what I was looking for
Instructions confusing or unclear
Instructions did not work

Want to tell us more?

Please select at least one option or provide details about the issue!!

Error occurred while submitting feedback.

Error2 occurred while submitting feedback.

TIBCO GridServer®

Copyright © 2001-2022. TIBCO Software Inc. All Rights Reserved.