Question

I have a centralized socket class which is responsible for sending and retrieving data. I have 2 classes:

• one which listens to the input stream and
• the other one which takes care of writing to it.

Listening running on an infinite loop and then process the messages. For synchronous i block the read and reset these values once i receive the response from the server.

Now i am stuck with asycnhronous. I have 3 methods in my service.

1. getSomething
2. readSomething
3. saySomething.

In my getSomething i want to implement async functionality based on the boolean flag provided. When my app starts i also start both of my threads and if i send concurrent request.

For example readSomething first and then getSomething then i get the return value for readSomething in getSomething which is not what i desire and i can see in the logs that the output for getSomething comes after a while.

It looks like the Future object requires to submit a new task which will run in it’s own thread but the way i have design this app, i just can’t create a new thread. Can anyone give me insights on how should i handle this asycnhronous like a flow chart etc ?.

Answer 1

If you’re doing work Asynchronously, that means that other part of the application does not care when the async work is done.

What you’ll normally want to do is notify the other part, when the async work is done. For this, you’ll want to use the “Observer Pattern” (the article includes flow-charts).

The basic idea is, that your app starts the async work and is notified, when the work is done. That way, you can loosely couple two parts of the application. A quick example:

/**
 * The observer
 */
public interface AsyncWorkDoneListener{

    /**
     * This method will be called when the async-thread is
     *  done.
     */
    public void done(Object unit);

}

/**
 * The worker (which does the asyc-work on another thread).
 */
public class AsyncWorker{

    private AsyncWorkDoneListener listener;

    /**
     * Set (you might want to maintain a list here) the current
     *  listener for this "AsyncWorker".
     */
    public void setListener(AsyncWorkDoneListener listener){
        this.listener = listener;
    }

    /**
     * Will do the async-work
     */
    public void doWork(){
        // Do the work in another thread...
        // When done, notify the registered listener with the
        //  result of the async work:
        this.listener.done(the_object_containing_the_result);
    }
}

/**
 * The application
 */
public class App implements AsyncWorkDoneListener{

    public void someMethod(){
        // Work on something asynchronously:
        mAsyncWorker.setListener(this);
        mAsyncWorker.doWork();
    }

    @Override
    public void done(Object unit){
        // The asyc work has finished, do something with
        //  the result in "unit".
    }
}