Asynchronous flow of execution in Java

Question

I'm writing a method where I want to query a database and perform another method after the query has finished. Since the call to the database is asynchronous, though, I can't seem to figure out how to stop the main flow of execution until the database call is complete, like so:

public void getUserFromEmail(String email) {
    Firebase usersRef = rootRef.child("users");

    //Asynchronous database call, want to stop everything else 
    usersRef.orderByKey().equalTo(email).addListenerForSingleValueEvent(new ValueEventListener() {
        @Override
        public void onDataChange(DataSnapshot dataSnapshot) {
        }

        @Override
        public void onCancelled(FirebaseError firebaseError) {
            System.out.println(firebaseError.getMessage());
        }
    });
    //Perform some more operations after database call is finished
}

I'm used to working with asynchronous callbacks in Nodejs, but I can't figure out if there's any equivalent way of controlling execution flow in Java. Is there any easy way to achieve what I want to do?

OneCricketeer · Answer 1 · 2016-10-15T19:17:20.470

You can't stop the main flow, the main thread will continue on. (Unless you otherwise stop it, but that will cause "Application Not Responding", so don't).

Just do the action in the callback.

public void getUserFromEmail(String email) {
    Firebase usersRef = rootRef.child("users");

    //Asynchronous database call, want to stop everything else 
    usersRef.orderByKey().equalTo(email).addListenerForSingleValueEvent(new ValueEventListener() {
        @Override
        public void onDataChange(DataSnapshot dataSnapshot) {
            // Perform some more operations after database call is finished
            // OR... callSomeMethod();
        }

        @Override
        public void onCancelled(FirebaseError firebaseError) {
            System.out.println(firebaseError.getMessage());
        }
    });

}

public void callSomeMethod() {
    // Perform some more operations after database call is finished
}

If you come from a Node background, then maybe this looks similar. Passing along the function to getUserFromEmail

public void otherMethod() {
    getUserFromEmail("steve@example.com", new ValueEventListener() {
        @Override
        public void onDataChange(DataSnapshot dataSnapshot) {
            // Perform some more operations after database call is finished
        }

        @Override
        public void onCancelled(FirebaseError firebaseError) {
            System.out.println(firebaseError.getMessage());
        }
    });
}

public void getUserFromEmail(String email, ValueEventListener listener) {
    rootRef.child("users")
        .orderByKey()
        .equalTo(email)
        .addListenerForSingleValueEvent(listener);
}

What if I wanted to return a value from the original meyhod once the callback is done? — Matt, Oct 11 '16 at 19:59
The method is `void`. You can't return. Nor, really, should you. Async doesn't play well with the `return` statement — OneCricketeer, Oct 11 '16 at 20:00
You can update the UI directly from the data you obtain from `dataSnapshot` within the callback — OneCricketeer, Oct 11 '16 at 20:01

Joseph Earl · Answer 2 · 2016-10-11T20:16:39.090

You can control the flow if you really want to using locks. For instance using CountdownLatch:

public DataSnapshot getUserFromEmail(String email) throws InterruptedException {
    AtomicReference<DataSnapshot> dataSnapshotRef = new AtomicReference<DataSnapshot>();
    CountDownLatch completeSignal = new CountDownLatch(1);

    Firebase usersRef = rootRef.child("users");

    //Asynchronous database call, want to stop everything else 
    usersRef.orderByKey().equalTo(email).addListenerForSingleValueEvent(new ValueEventListener() {
        @Override
        public void onDataChange(DataSnapshot dataSnapshot) {
            dataSnapshotRef.set(dataSnapshot);
            // Causes execution of the waiting thread to continue
            // from the `await` call
            completeSignal.countDown();
        }

        @Override
        public void onCancelled(FirebaseError firebaseError) {
            completeSignal.countDown();
        }
    });

    // Execution on this thread pauses at the `await` call until
    // countDown has been called from another thread.
    completeSignal.await();

    // Do stuff after onDataChanged or onCancelled has been called
    DataSnapshot dataSnapshot = dataSnapshotRef.get();
}

However this approach will block the thread that executed getUserFromEmail until Firebase has returned some data. Particularly, if you call getUserFromEmail from your UI thread then this will block the UI thread and cause an ANR.

It is better to follow the callback approach like so:

public DataSnapshot getUserFromEmail(String email, ValueEventListener listener) {
    Firebase usersRef = rootRef.child("users");

    //Asynchronous database call, want to stop everything else 
    usersRef.orderByKey().equalTo(email).addListenerForSingleValueEvent(listener);
}

public void getUserAndThenDoSomething() {
    getUserFromEmail("bob@example.com", new ValueEventListener() {
        @Override
        public void onDataChange(DataSnapshot dataSnapshot) {
            // Do stuff after getting the email here
        }

        @Override
        public void onCancelled(FirebaseError firebaseError) {
        }
    });
}

Last time I checked that lead to ANRs. See my update in http://stackoverflow.com/a/33204705/209103 — Frank van Puffelen, Oct 11 '16 at 20:15
If you execute it in the UI thread, then yes, otherwise no. Added to the answer to warn people about using that method from UI thread. — Joseph Earl, Oct 11 '16 at 20:15

Asynchronous flow of execution in Java

2 Answers2