How to show the current throughput of n theads?

Imagine having n-Threads which all work on a SOAP endpoint to acquire some data and store it onto the file system. What's the best way to display the throughput of these threads for the last second?

I came around with the following idea:

All 32 (n in this case) threads hold an AtomicInteger which is increased by every thread after one file was written to the file system. This AtomicInteger is then evaluated by another thread (#33), which is just there for logging this AtomicInteger divided by n-Threads, estimating the ETA by using metrics (total amount of entries left / throughput) resetting the AtomicInteger to zero and then sleeps one second and continue looping until all threads finished their work.

However, this has the following problem: The locking of the AtomicInteger will cause some loss of performance (although I'd consider it negligible) and the output will never be the last second, since there will be some variance in locking times.

Can anyone think of a more elegant solution to this problem? I guess I might be overthinking this completely and Java already has some solution for it.

Even if there might a 3rd-party solution or package for this, I'd rather understand how to do this properly than just to use a package.

The threads are spawned by an ExecutorService and all threads are of the Runnable kind.

The easiest way is to update only n th time, for example only every 100 calls if AtomicInteger is a bottleneck. I would suggest first use an Atomicinteger and only when you see that there is a problem use a more complicated solution.
there are libraries for sampling statistics, for example, https://github.com/HdrHistogram/HdrHistogram but since you want to measure only one endpoint this does not fit your needs.

I think you have a very customized requirement regarding metrics collection. I doubt that there are any metrics collection libraries doing what you are expecting. Maybe checkout micrometers GaugeCounter.

Problem Root:
You are trying to read and write to the same resource concurrently by n+1 workers. The use case allows you to use variation of Scatter/Gather pattern where one worker can aggregate the work of n workers and n workers can read/write n resources owned by themselves.

Assumption:
I am assuming that you have references to all those threads in a list or array and you don't have files more than Integer.MAX_VALUE.

Solution:
You can use volatile int as a composition in each thread instead of passing AtomicInteger from the outside. These counters will be monotonically increasing and are never modified or reset in the computation thread.

You can keep a local copy of int values in the computation thread and subtract this local copy from the new values to obtain the files processed in the last second and update the local copy with the new values (This will be equivalent to resetting the counter to 0 for each thread). Alternatively, if you could, you can just keep track of the summation of the counters instead of storing counter for each thread.

class Computation implements Runnable {
List<Worker> workerList;
int[] localCounters;
boolean finished;
public Computation(List<Worker> workerList) {
this.workerList = workerList;
this.localCounters = new int[workerList.size()];
}
@Override
public void run() {
while (!finished) {
for (int i = 0; i < workerList.size(); i++) {
localCounters[i] = workerList.get(i).getCounter();
}
computation();
pause();
}
}
private void computation(){
//do your computation with localCounters
//this.localCounters[x]
}
private boolean isFinished () {
return finished;
}
private void pause() {
try {
Thread.sleep(1000L);
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class Worker implements Runnable {
private volatile int counter;
@Override
public void run() {
// do your thing.
}
public int getCounter() {
return counter;
}
}