Empty Map when using Executors

I'm trying to count for each minute the records with the same type as in the parameter in a List, in a given time range. Using the following Method:

public Map<String, Object> getCountPerMinuteForType(final String type,
                                 final long startTimestamp,
                                 final long endTimestamp) {
    final Map<String, Object> countsPerMinForType = new HashMap<>();
    Executors.newSingleThreadScheduledExecutor().scheduleAtFixedRate(() -> {
            int counter = 0;
            List<Data> dataList = storage.retrieveData();
            for(Data data: dataList){
                if (data.getType().equals(type) &&
                    data.getUnixTimestamp() >= startTimestamp &&
                    data.getUnixTimestamp() <= endTimestamp){
                    counter++;
                }
            }
            countsPerMinForType.put(type, counter);
        }, 0, 1, TimeUnit.MINUTES);
    return countsPerMinForType;
}

The problem is, this method returns an empty Map.

When I print the contents of the Map inside the Executors, I can see that it has data.

It happens because an another thread is performing put operation in the Map. The main thread starts execution of the thread and then returns back to the place where it was called. To solve this issue, you may need to create a listener interface which gets called whenever the second thread performs the task.

Here, below is the code sample which you can use and modify according to your needs.

class Test implements Listener {
private Listener listener;
public Test() {
listener = this; //Set this class as your listener
}
//Make your function return nothing
public void getCountPerMinuteForType(final String type, final long startTimestamp, 
final long endTimestamp) {
final Map<String, Object> countsPerMinForType = new HashMap<>();
ScheduledExecutorService service = 
Executors.newSingleThreadScheduledExecutor().scheduleAtFixedRate(() -> {
int counter = 0;
List<Data> dataList = storage.retrieveData();
for (Data data : dataList) {
if (data.getType().equals(type) &&
data.getUnixTimestamp() >= startTimestamp &&
data.getUnixTimestamp() <= endTimestamp) {
counter++;
}
}
listener.onNewData(type, counter);
countsPerMinForType.put(type, counter);
}, 0, 1, TimeUnit.MINUTES);
//return countsPerMinForType;
//If service is terminated call the listener and perform your operation there
if (service.isTerminated()) {
listener.dataFilled(countsPerMinForType);
}
}
@Override
public void onNewData(String str, Object obj) {
//Perform your task here
}
@Override
public void dataFilled(Map<String, Object> data) {
//Perform your task here
}
}
interface Listener {
void dataFilled(Map<String, Object> data);
void onNewData(Map<String, Object> data);
}

The issue you have is that you're expecting the thread you're spinning off has completed the work and the results populated in the countsPerMinForType are returned. This is not what is happening...

What is happening is:

1. you call the method from the main/current thread of execution
2. the Map is created
3. a new thread is spun off to do some work
4. almost immediately, the method returns and the map is still empty.
   ...
5. after the method has completed, the work being performed by the spun off thread is then carried out... and subsequently the calling method never sees the result.

You can confirm this is the case with a test that returns a timestamp for when the getCountPerMinuteForType starts and ends, and another timestamp for when the Thread starts and ends. The start times will be in order, the end times will not be in order.

Also, you may want to consider using a ConcurrentHashMap for a multi-threaded application.