Stop UI-method until Async task is finished

Sorry for me poor english.

i am messing about with a java class that needs to do UI-work. but the UI-work needs to wait for an async task. The asyncTask retrieves api soap from internet. Once api is retrieved it is set to global jsonResponseBody. Then UI-method then uses jsonResponseBody to do UI-stuff.

In my now code, I use while-loop to stop from moving on before jsonResponseBody is ready. Is while-loop best idea for me? I think maybe while-loop will slow down main-thread, no?

    //Pre-async task stuff is run
    connectDbAsync(db,sqlQuery); //This will set jsonResponseBody sooner or later
    while(jsonResponseBody == null){
        //Do nothing, just wait
    }
    //Post-async task stuff which uses jsonResponseBody

You might have a look at java Future. You can use it to launch some code asynchronously but you get a handle to it and so you can check if it is finished (Future.isDone()) or block until it is finished: Future.get()

When performing asynchronous tasks in Java there are several ways to handle output. One way as you discovered, is to use a loop to block code execution until the task completes. I personally like to use a thread pool and Future objects to wait on my threads to complete. There are some advantages and disadvantages to both approaches, however in your case, your while loop should not slow your main thread because it only runs for a finite period of time and runs immediately after you start executing your asynchronous task.

That said, the benefit of an asynchronous task is that it can do its thing while your code is doing something else. If you MUST wait on the asynchronous task to complete before continuing on in your method, then the task could be done synchronously instead and you wouldn't need the loop to pause execution.

Example blocking code that waits on network poll of multiple "sites" before continuing execution. This shows the benefit of asynchronous tasks/multithreading when it comes to doing multiple things at one time:

            //Invoke run method on each site simultaneously, store results in a list
            List<Future<Site>> futures=threadmaker.invokeAll(active_sites.stream().map(TAG_SCANNER::new).collect(Collectors.toList()));
        
            List<Site> alarm_sites = new ArrayList<>();
            //Now fetch all the results serially
            for(Future<Site> result: futures){
                //SOUND THE ALARMS
                alarm_sites.add(result.get());
            }
// Continue synchronous method execution