Синхронизация работы listener

void main()
{
//...
        ConcurrentHashMap<String, User> userMap = new ConcurrentHashMap<String, User>();
        DBConnector connector = new DBConnector();
 
        connector.getUsersHashMap(userMap);
 
        synchronized (userMap)
        {
            while (userMap.isEmpty()){
                try {
                    userMap.wait();
                }
                catch (InterruptedException e) {
                }
            }
        }
 
 
//...
}

public synchronized ConcurrentHashMap<String, User> getUsersHashMap(final ConcurrentHashMap<String, User> hashMap) {
    synchronized (hashMap) {
        final FirebaseDatabase database = FirebaseDatabase.getInstance();
        DatabaseReference ref = database.getReference("/users");
        ref.addListenerForSingleValueEvent(new ValueEventListener() {
            public void onDataChange(DataSnapshot dataSnapshot) {
                for (DataSnapshot userSnapshot : dataSnapshot.getChildren()) {
                    hashMap.put(...)
                    );
                }
            }
 
            public void onCancelled(DatabaseError databaseError) {
                System.out.println("The read failed: " + databaseError.getCode());
            }
        });
        hashMap.notify();
        return hashMap;
    }
}

import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
 
public final class Sublimee {
 
    public static void main(String[] args) {
        final ExecutorService executor = Executors.newSingleThreadExecutor();
        final Future<Map<String, User>> usersFetch = executor.submit(() -> {
            try {
                return getAllUsers().stream().collect(Collectors.toMap(
                        User::getId,
                        Function.identity()
                ));
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new ExecutionException("Interrupted!", e);
            }
        });
        try {
            println("Can do some shit while users are loading…");
            Thread.sleep(1000L);
 
            println("Can do some more shit…");
            Thread.sleep(1000L);
 
            println("Ok, it's borring. Let's lock and wait for users to be loaded…");
            final Map<String, User> users = usersFetch.get();
 
            println("Now we get some users!");
            users.forEach((id, user) -> println(id + ". " + user));
 
        } catch (ExecutionException e) {
            println("Something went wrong while loading users: " + e.getMessage());
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            println("Interrupted!");
        } finally {
            executor.shutdown();
        }
    }
 
    private static List<User> getAllUsers() throws InterruptedException {
        Thread.sleep(4000L); // simulate long loading
        return Stream.of(
                new User("1", "Vasily", "Pupkin"),
                new User("2", "Alexey", "Parovozkin")
        ).collect(Collectors.toList());
    }
 
    private static void println(String s) {
        System.out.println(LocalTime.now().format(DateTimeFormatter.ISO_TIME) + ": " + s);
    }
 
    private static final class User {
 
        private final String id;
        private final String firstName;
        private final String lastName;
 
        public User(String id, String firstName, String lastName) {
            this.id = id;
            this.firstName = firstName;
            this.lastName = lastName;
        }
 
        public String getId() {
            return id;
        }
 
        public String getFirstName() {
            return firstName;
        }
 
        public String getLastName() {
            return lastName;
        }
 
        @Override
        public String toString() {
            return firstName + ' ' + lastName;
        }
    }
}